diff --git a/.github/workflows/nix-linux-cu10.yml b/.github/workflows/nix-linux-cu10.yml
index 423fbf697..6362d53b8 100644
--- a/.github/workflows/nix-linux-cu10.yml
+++ b/.github/workflows/nix-linux-cu10.yml
@@ -29,4 +29,4 @@ jobs:
         skipNixBuild: false
         name: hasktorch
         signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'
-        nixBuildArgs: -A libtorch-ffi_cudatoolkit_10_1 -A hasktorch_cudatoolkit_10_1 -A hasktorch-examples_cudatoolkit_10_1 -A hasktorch-experimental_cudatoolkit_10_1
+        nixBuildArgs: -A libtorch-ffi_cudatoolkit_10_2 -A hasktorch_cudatoolkit_10_2 -A hasktorch-examples_cudatoolkit_10_2 -A hasktorch-experimental_cudatoolkit_10_2
diff --git a/cabal.project b/cabal.project
index 09f23d380..2d1612698 100644
--- a/cabal.project
+++ b/cabal.project
@@ -3,11 +3,6 @@ source-repository-package
     location: git://github.com/hasktorch/pipes-text.git
     tag: 3dd3d9519306ea06f0c15ad71bdf57e1dfd0b747
 
-source-repository-package
-    type: git
-    location: git://github.com/RyanGlScott/blaze-markup.git
-    tag: 66b7b3106eb35f57939357e7fb1288f503d6f833
-
 source-repository-package
     type: git
     location: git://github.com/well-typed/cborg.git
diff --git a/cabal.project.freeze.ghc810 b/cabal.project.freeze.ghc810
index 6626aa7d1..1c08b9e8d 100644
--- a/cabal.project.freeze.ghc810
+++ b/cabal.project.freeze.ghc810
@@ -39,6 +39,7 @@ constraints: any.Cabal ==3.0.2.0,
              any.binary ==0.8.8.0,
              any.blaze-builder ==0.4.1.0,
              any.blaze-html ==0.9.1.2,
+             any.blaze-markup ==0.8.2.5,
              any.bytestring ==0.10.10.0,
              any.cabal-doctest ==1.0.8,
              any.call-stack ==0.2.0,
diff --git a/codegen/src/RenderCommon.hs b/codegen/src/RenderCommon.hs
index e96852c0f..e196c250e 100644
--- a/codegen/src/RenderCommon.hs
+++ b/codegen/src/RenderCommon.hs
@@ -341,6 +341,13 @@ isCType p =
     Ptr _ -> True
     _ -> False
 
+isGenerator :: Parsable -> Bool
+isGenerator p =
+  case p of
+    Ptr GeneratorType -> True
+    GeneratorType -> True
+    _ -> False
+
 isNotStar :: Parameter -> Bool
 isNotStar p =
   case p of
@@ -437,7 +444,9 @@ functionToCpp is_managed add_type_initials prefix suffix fn =
       else "Ptr"
     types_list :: [Text]
     types_list = flip map parameters' $ \p ->
-      if isCType (ptype p)
+      if is_managed && isGenerator (ptype p)
+      then [st|#{pointer} #{parsableToHsType GeneratorType}|]
+      else if isCType (ptype p)
       then [st|#{parsableToHsType (ptype p)}|]
       else [st|#{pointer} #{parsableToHsType (ptype p)}|]
     types :: Text
@@ -539,7 +548,9 @@ methodToCpp class' is_constructor is_managed add_type_initials prefix suffix fn
       else "Ptr"
     types_list :: [Text]
     types_list = flip map parameters' $ \p ->
-      if isCType (ptype p)
+      if is_managed && isGenerator (ptype p)
+      then [st|#{pointer} #{parsableToHsType GeneratorType}|]
+      else if isCType (ptype p)
       then [st|#{parsableToHsType (ptype p)}|]
       else [st|#{pointer} #{parsableToHsType (ptype p)}|]
     types :: Text
diff --git a/default.nix b/default.nix
index 305082d64..8176c1ce0 100644
--- a/default.nix
+++ b/default.nix
@@ -15,8 +15,8 @@ in
     ${shared.nullIfDarwin "hasktorch-examples_cudatoolkit_9_2"} = shared.hasktorch-examples_cudatoolkit_9_2;
     ${shared.nullIfDarwin "hasktorch-experimental_cudatoolkit_9_2"} = shared.hasktorch-experimental_cudatoolkit_9_2;
 
-    ${shared.nullIfDarwin "libtorch-ffi_cudatoolkit_10_1"} = shared.libtorch-ffi_cudatoolkit_10_1;
-    ${shared.nullIfDarwin "hasktorch_cudatoolkit_10_1"} = shared.hasktorch_cudatoolkit_10_1;
-    ${shared.nullIfDarwin "hasktorch-examples_cudatoolkit_10_1"} = shared.hasktorch-examples_cudatoolkit_10_1;
-    ${shared.nullIfDarwin "hasktorch-experimental_cudatoolkit_10_1"} = shared.hasktorch-experimental_cudatoolkit_10_1;
+    ${shared.nullIfDarwin "libtorch-ffi_cudatoolkit_10_2"} = shared.libtorch-ffi_cudatoolkit_10_2;
+    ${shared.nullIfDarwin "hasktorch_cudatoolkit_10_2"} = shared.hasktorch_cudatoolkit_10_2;
+    ${shared.nullIfDarwin "hasktorch-examples_cudatoolkit_10_2"} = shared.hasktorch-examples_cudatoolkit_10_2;
+    ${shared.nullIfDarwin "hasktorch-experimental_cudatoolkit_10_2"} = shared.hasktorch-experimental_cudatoolkit_10_2;
   }
diff --git a/deps/get-deps.sh b/deps/get-deps.sh
index 50a916962..36264ac83 100755
--- a/deps/get-deps.sh
+++ b/deps/get-deps.sh
@@ -8,16 +8,17 @@
 set -eu
 
 usage_exit() {
-    echo "Usage: $0 [-n] [-c] [-a "cpu" or "cu92" or "cu101"] [-s]" 1>&2
+    echo "Usage: $0 [-n] [-c] [-a "cpu" or "cu92" or "cu101" or "cu102"] [-s]" 1>&2
     echo " -n # Use nightly libtorch w/  -l" 1>&2
-    echo "    # Use libtorch-1.4.0   w/o -l" 1>&2
+    echo "    # Use libtorch-1.5.0   w/o -l" 1>&2
     echo "" 1>&2
     echo " -c # Download libtorch from hasktorch's site w/ -c" 1>&2
     echo "    # Download libtorch from pytorch's site w/o  -c" 1>&2
     echo "" 1>&2
     echo " -a cpu   # Use CPU without CUDA" 1>&2
     echo " -a cu92  # Use CUDA-9" 1>&2
-    echo " -a cu101 # Use CUDA-10" 1>&2
+    echo " -a cu101 # Use CUDA-10.1" 1>&2
+    echo " -a cu102 # Use CUDA-10.2" 1>&2
     echo "" 1>&2
     echo " -s # Skip download" 1>&2
     echo "" 1>&2
@@ -29,7 +30,7 @@ USE_NIGHTLY=0
 USE_BINARY_FOR_CI=0
 COMPUTE_ARCH=cpu
 SKIP_DOWNLOAD=0
-VERSION=1.4.0
+VERSION=1.5.0
 
 while getopts nca:sh OPT
 do
@@ -90,7 +91,8 @@ if [ "$SKIP_DOWNLOAD" = 0 ] ; then
 	case "${COMPUTE_ARCH}" in
 	      "cpu" )   URL=https://download.pytorch.org/libtorch/${COMPUTE_ARCH}/libtorch-cxx11-abi-shared-with-deps-${VERSION}%2Bcpu.zip ;;
 	      "cu92" ) URL=https://download.pytorch.org/libtorch/${COMPUTE_ARCH}/libtorch-cxx11-abi-shared-with-deps-${VERSION}%2Bcu92.zip ;;
-	      "cu101" )   URL=https://download.pytorch.org/libtorch/${COMPUTE_ARCH}/libtorch-cxx11-abi-shared-with-deps-${VERSION}.zip ;;
+	      "cu101" )   URL=https://download.pytorch.org/libtorch/${COMPUTE_ARCH}/libtorch-cxx11-abi-shared-with-deps-${VERSION}%2Bcu101.zip ;;
+	      "cu102" )   URL=https://download.pytorch.org/libtorch/${COMPUTE_ARCH}/libtorch-cxx11-abi-shared-with-deps-${VERSION}.zip ;;
 	esac
 	wget -O libtorch-cxx11-abi-shared-with-deps-${VERSION}.zip "$URL"
         unzip libtorch-cxx11-abi-shared-with-deps-${VERSION}.zip
@@ -126,11 +128,11 @@ $PYTHON aten/src/ATen/gen.py \
   -s aten/src/ATen \
   -d build/aten/src/ATen \
   aten/src/ATen/Declarations.cwrap \
-  aten/src/THNN/generic/THNN.h \
   aten/src/THCUNN/generic/THCUNN.h \
   aten/src/ATen/nn.yaml \
   aten/src/ATen/native/native_functions.yaml
 
+
 # Sanitize "name: n" fields to be strings rather than booleans in Declarations.yaml
 
 case "$(uname)" in
diff --git a/deps/pytorch b/deps/pytorch
index 7f73f1d59..4ff3872a2 160000
--- a/deps/pytorch
+++ b/deps/pytorch
@@ -1 +1 @@
-Subproject commit 7f73f1d591afba823daa4a99a939217fb54d7688
+Subproject commit 4ff3872a2099993bf7e8c588f7182f3df777205b
diff --git a/examples/shell.nix b/examples/shell.nix
index 9b3b7f77d..7160102de 100644
--- a/examples/shell.nix
+++ b/examples/shell.nix
@@ -8,4 +8,4 @@ if cudaVersion == null
 then shared.shell-hasktorch-examples_cpu
 else if cudaVersion == 9
   then shared.shell-hasktorch-examples_cudatoolkit_9_2
-  else shared.shell-hasktorch-examples_cudatoolkit_10_1
+  else shared.shell-hasktorch-examples_cudatoolkit_10_2
diff --git a/experimental/shell.nix b/experimental/shell.nix
index 0cee91a92..5eb00ef5b 100644
--- a/experimental/shell.nix
+++ b/experimental/shell.nix
@@ -8,4 +8,4 @@ if cudaVersion == null
 then shared.shell-hasktorch-experimental_cpu
 else if cudaVersion == 9
   then shared.shell-hasktorch-experimental_cudatoolkit_9_2
-  else shared.shell-hasktorch-experimental_cudatoolkit_10_1
+  else shared.shell-hasktorch-experimental_cudatoolkit_10_2
diff --git a/hasktorch/hasktorch.cabal b/hasktorch/hasktorch.cabal
index 00f8f00a9..1bb5b5ff9 100644
--- a/hasktorch/hasktorch.cabal
+++ b/hasktorch/hasktorch.cabal
@@ -65,7 +65,7 @@ library
  ghc-options:         -fplugin GHC.TypeLits.Normalise -fplugin GHC.TypeLits.KnownNat.Solver -fplugin GHC.TypeLits.Extra.Solver -fconstraint-solver-iterations=0
  build-depends:       async
                     , base >= 4.7 && < 5
-                    , libtorch-ffi == 1.4.*
+                    , libtorch-ffi == 1.5.*
                     , finite-typelits
                     -- , ghc-typelits-extra >= 0.3.1
                     -- , ghc-typelits-knownnat >= 0.7
diff --git a/hasktorch/shell.nix b/hasktorch/shell.nix
index 2ff37082e..387bef12d 100644
--- a/hasktorch/shell.nix
+++ b/hasktorch/shell.nix
@@ -8,4 +8,4 @@ if cudaVersion == null
 then shared.shell-hasktorch_cpu
 else if cudaVersion == 9
   then shared.shell-hasktorch_cudatoolkit_9_2
-  else shared.shell-hasktorch_cudatoolkit_10_1
+  else shared.shell-hasktorch_cudatoolkit_10_2
diff --git a/hasktorch/src/Torch/Functional/Internal.hs b/hasktorch/src/Torch/Functional/Internal.hs
index 72c13dfee..a949856c7 100644
--- a/hasktorch/src/Torch/Functional/Internal.hs
+++ b/hasktorch/src/Torch/Functional/Internal.hs
@@ -252,6 +252,18 @@ batch_norm
   -> Tensor
 batch_norm _input _weight _bias _running_mean _running_var _training _momentum _eps _cudnn_enabled = unsafePerformIO $ (cast9 ATen.batch_norm_tttttbddb) _input _weight _bias _running_mean _running_var _training _momentum _eps _cudnn_enabled
 
+quantized_batch_norm
+  :: Tensor -- ^ input
+  -> Tensor -- ^ weight
+  -> Tensor -- ^ bias
+  -> Tensor -- ^ mean
+  -> Tensor -- ^ var
+  -> Double -- ^ eps
+  -> Double -- ^ output_scale
+  -> Int -- ^ output_zero_point
+  -> Tensor
+quantized_batch_norm _input _weight _bias _mean _var _eps _output_scale _output_zero_point = unsafePerformIO $ (cast8 ATen.quantized_batch_norm_tttttddl) _input _weight _bias _mean _var _eps _output_scale _output_zero_point
+
 bilinear
   :: Tensor -- ^ input1
   -> Tensor -- ^ input2
@@ -260,6 +272,23 @@ bilinear
   -> Tensor
 bilinear _input1 _input2 _weight _bias = unsafePerformIO $ (cast4 ATen.bilinear_tttt) _input1 _input2 _weight _bias
 
+binary_cross_entropy
+  :: Tensor -- ^ self
+  -> Tensor -- ^ target
+  -> Tensor -- ^ weight
+  -> Int -- ^ reduction
+  -> Tensor
+binary_cross_entropy _self _target _weight _reduction = unsafePerformIO $ (cast4 ATen.binary_cross_entropy_tttl) _self _target _weight _reduction
+
+binary_cross_entropy_backward
+  :: Tensor -- ^ grad_output
+  -> Tensor -- ^ self
+  -> Tensor -- ^ target
+  -> Tensor -- ^ weight
+  -> Int -- ^ reduction
+  -> Tensor
+binary_cross_entropy_backward _grad_output _self _target _weight _reduction = unsafePerformIO $ (cast5 ATen.binary_cross_entropy_backward_ttttl) _grad_output _self _target _weight _reduction
+
 binary_cross_entropy_with_logits
   :: Tensor -- ^ self
   -> Tensor -- ^ target
@@ -302,6 +331,18 @@ logical_xor
   -> Tensor
 logical_xor _self _other = unsafePerformIO $ (cast2 ATen.logical_xor_tt) _self _other
 
+logical_and
+  :: Tensor -- ^ self
+  -> Tensor -- ^ other
+  -> Tensor
+logical_and _self _other = unsafePerformIO $ (cast2 ATen.logical_and_tt) _self _other
+
+logical_or
+  :: Tensor -- ^ self
+  -> Tensor -- ^ other
+  -> Tensor
+logical_or _self _other = unsafePerformIO $ (cast2 ATen.logical_or_tt) _self _other
+
 bmm
   :: Tensor -- ^ self
   -> Tensor -- ^ mat2
@@ -561,7 +602,7 @@ cudnn_batch_norm_backward
   -> (Tensor,Tensor,Tensor)
 cudnn_batch_norm_backward _input _grad_output _weight _running_mean _running_var _save_mean _save_var _epsilon _reserveSpace = unsafePerformIO $ (cast9 ATen.cudnn_batch_norm_backward_tttttttdt) _input _grad_output _weight _running_mean _running_var _save_mean _save_var _epsilon _reserveSpace
 
-cudnn_convolution
+cudnn_convolution_tttllllbb
   :: Tensor -- ^ self
   -> Tensor -- ^ weight
   -> Tensor -- ^ bias
@@ -572,7 +613,19 @@ cudnn_convolution
   -> Bool -- ^ benchmark
   -> Bool -- ^ deterministic
   -> Tensor
-cudnn_convolution _self _weight _bias _padding _stride _dilation _groups _benchmark _deterministic = unsafePerformIO $ (cast9 ATen.cudnn_convolution_tttllllbb) _self _weight _bias _padding _stride _dilation _groups _benchmark _deterministic
+cudnn_convolution_tttllllbb _self _weight _bias _padding _stride _dilation _groups _benchmark _deterministic = unsafePerformIO $ (cast9 ATen.cudnn_convolution_tttllllbb) _self _weight _bias _padding _stride _dilation _groups _benchmark _deterministic
+
+cudnn_convolution_ttllllbb
+  :: Tensor -- ^ self
+  -> Tensor -- ^ weight
+  -> [Int] -- ^ padding
+  -> [Int] -- ^ stride
+  -> [Int] -- ^ dilation
+  -> Int -- ^ groups
+  -> Bool -- ^ benchmark
+  -> Bool -- ^ deterministic
+  -> Tensor
+cudnn_convolution_ttllllbb _self _weight _padding _stride _dilation _groups _benchmark _deterministic = unsafePerformIO $ (cast8 ATen.cudnn_convolution_ttllllbb) _self _weight _padding _stride _dilation _groups _benchmark _deterministic
 
 cudnn_convolution_backward_input
   :: [Int] -- ^ self_size
@@ -597,15 +650,10 @@ cudnn_convolution_backward
   -> Int -- ^ groups
   -> Bool -- ^ benchmark
   -> Bool -- ^ deterministic
-  -> (Bool,Bool,Bool) -- ^ output_mask
-  -> (Tensor,Tensor,Tensor)
+  -> (Bool,Bool) -- ^ output_mask
+  -> (Tensor,Tensor)
 cudnn_convolution_backward _self _grad_output _weight _padding _stride _dilation _groups _benchmark _deterministic _output_mask = unsafePerformIO $ (cast10 ATen.cudnn_convolution_backward_tttllllbba) _self _grad_output _weight _padding _stride _dilation _groups _benchmark _deterministic _output_mask
 
-cudnn_convolution_backward_bias
-  :: Tensor -- ^ grad_output
-  -> Tensor
-cudnn_convolution_backward_bias _grad_output = unsafePerformIO $ (cast1 ATen.cudnn_convolution_backward_bias_t) _grad_output
-
 cudnn_convolution_backward_weight
   :: [Int] -- ^ weight_size
   -> Tensor -- ^ grad_output
@@ -619,7 +667,7 @@ cudnn_convolution_backward_weight
   -> Tensor
 cudnn_convolution_backward_weight _weight_size _grad_output _self _padding _stride _dilation _groups _benchmark _deterministic = unsafePerformIO $ (cast9 ATen.cudnn_convolution_backward_weight_lttllllbb) _weight_size _grad_output _self _padding _stride _dilation _groups _benchmark _deterministic
 
-cudnn_convolution_transpose
+cudnn_convolution_transpose_tttlllllbb
   :: Tensor -- ^ self
   -> Tensor -- ^ weight
   -> Tensor -- ^ bias
@@ -631,7 +679,20 @@ cudnn_convolution_transpose
   -> Bool -- ^ benchmark
   -> Bool -- ^ deterministic
   -> Tensor
-cudnn_convolution_transpose _self _weight _bias _padding _output_padding _stride _dilation _groups _benchmark _deterministic = unsafePerformIO $ (cast10 ATen.cudnn_convolution_transpose_tttlllllbb) _self _weight _bias _padding _output_padding _stride _dilation _groups _benchmark _deterministic
+cudnn_convolution_transpose_tttlllllbb _self _weight _bias _padding _output_padding _stride _dilation _groups _benchmark _deterministic = unsafePerformIO $ (cast10 ATen.cudnn_convolution_transpose_tttlllllbb) _self _weight _bias _padding _output_padding _stride _dilation _groups _benchmark _deterministic
+
+cudnn_convolution_transpose_ttlllllbb
+  :: Tensor -- ^ self
+  -> Tensor -- ^ weight
+  -> [Int] -- ^ padding
+  -> [Int] -- ^ output_padding
+  -> [Int] -- ^ stride
+  -> [Int] -- ^ dilation
+  -> Int -- ^ groups
+  -> Bool -- ^ benchmark
+  -> Bool -- ^ deterministic
+  -> Tensor
+cudnn_convolution_transpose_ttlllllbb _self _weight _padding _output_padding _stride _dilation _groups _benchmark _deterministic = unsafePerformIO $ (cast9 ATen.cudnn_convolution_transpose_ttlllllbb) _self _weight _padding _output_padding _stride _dilation _groups _benchmark _deterministic
 
 cudnn_convolution_transpose_backward
   :: Tensor -- ^ self
@@ -644,15 +705,10 @@ cudnn_convolution_transpose_backward
   -> Int -- ^ groups
   -> Bool -- ^ benchmark
   -> Bool -- ^ deterministic
-  -> (Bool,Bool,Bool) -- ^ output_mask
-  -> (Tensor,Tensor,Tensor)
+  -> (Bool,Bool) -- ^ output_mask
+  -> (Tensor,Tensor)
 cudnn_convolution_transpose_backward _self _grad_output _weight _padding _output_padding _stride _dilation _groups _benchmark _deterministic _output_mask = unsafePerformIO $ (cast11 ATen.cudnn_convolution_transpose_backward_tttlllllbba) _self _grad_output _weight _padding _output_padding _stride _dilation _groups _benchmark _deterministic _output_mask
 
-cudnn_convolution_transpose_backward_bias
-  :: Tensor -- ^ grad_output
-  -> Tensor
-cudnn_convolution_transpose_backward_bias _grad_output = unsafePerformIO $ (cast1 ATen.cudnn_convolution_transpose_backward_bias_t) _grad_output
-
 cudnn_convolution_transpose_backward_input
   :: Tensor -- ^ grad_output
   -> Tensor -- ^ weight
@@ -691,19 +747,29 @@ cudnn_grid_sampler_backward
   -> (Tensor,Tensor)
 cudnn_grid_sampler_backward _self _grid _grad_output = unsafePerformIO $ (cast3 ATen.cudnn_grid_sampler_backward_ttt) _self _grid _grad_output
 
-cumsum
+cummax_tl
   :: Tensor -- ^ self
   -> Int -- ^ dim
-  -> DType -- ^ dtype
-  -> Tensor
-cumsum _self _dim _dtype = unsafePerformIO $ (cast3 ATen.cumsum_tls) _self _dim _dtype
+  -> (Tensor,Tensor)
+cummax_tl _self _dim = unsafePerformIO $ (cast2 ATen.cummax_tl) _self _dim
 
-cumsumWithDimname
+cummax_tn
   :: Tensor -- ^ self
   -> Dimname -- ^ dim
-  -> DType -- ^ dtype
-  -> Tensor
-cumsumWithDimname _self _dim _dtype = unsafePerformIO $ (cast3 ATen.cumsum_tns) _self _dim _dtype
+  -> (Tensor,Tensor)
+cummax_tn _self _dim = unsafePerformIO $ (cast2 ATen.cummax_tn) _self _dim
+
+cummin_tl
+  :: Tensor -- ^ self
+  -> Int -- ^ dim
+  -> (Tensor,Tensor)
+cummin_tl _self _dim = unsafePerformIO $ (cast2 ATen.cummin_tl) _self _dim
+
+cummin_tn
+  :: Tensor -- ^ self
+  -> Dimname -- ^ dim
+  -> (Tensor,Tensor)
+cummin_tn _self _dim = unsafePerformIO $ (cast2 ATen.cummin_tn) _self _dim
 
 cumprod
   :: Tensor -- ^ self
@@ -719,6 +785,20 @@ cumprodWithDimname
   -> Tensor
 cumprodWithDimname _self _dim _dtype = unsafePerformIO $ (cast3 ATen.cumprod_tns) _self _dim _dtype
 
+cumsum
+  :: Tensor -- ^ self
+  -> Int -- ^ dim
+  -> DType -- ^ dtype
+  -> Tensor
+cumsum _self _dim _dtype = unsafePerformIO $ (cast3 ATen.cumsum_tls) _self _dim _dtype
+
+cumsumWithDimname
+  :: Tensor -- ^ self
+  -> Dimname -- ^ dim
+  -> DType -- ^ dtype
+  -> Tensor
+cumsumWithDimname _self _dim _dtype = unsafePerformIO $ (cast3 ATen.cumsum_tns) _self _dim _dtype
+
 ctcLoss'
   :: Tensor -- ^ log_probs
   -> Tensor -- ^ targets
@@ -760,13 +840,22 @@ diagflat
   -> Tensor
 diagflat _self _offset = unsafePerformIO $ (cast2 ATen.diagflat_tl) _self _offset
 
-diagonal
+diagonal_tlll
   :: Tensor -- ^ self
   -> Int -- ^ offset
   -> Int -- ^ dim1
   -> Int -- ^ dim2
   -> Tensor
-diagonal _self _offset _dim1 _dim2 = unsafePerformIO $ (cast4 ATen.diagonal_tlll) _self _offset _dim1 _dim2
+diagonal_tlll _self _offset _dim1 _dim2 = unsafePerformIO $ (cast4 ATen.diagonal_tlll) _self _offset _dim1 _dim2
+
+diagonal_tnnnl
+  :: Tensor -- ^ self
+  -> Dimname -- ^ outdim
+  -> Dimname -- ^ dim1
+  -> Dimname -- ^ dim2
+  -> Int -- ^ offset
+  -> Tensor
+diagonal_tnnnl _self _outdim _dim1 _dim2 _offset = unsafePerformIO $ (cast5 ATen.diagonal_tnnnl) _self _outdim _dim1 _dim2 _offset
 
 div
   :: Tensor -- ^ self
@@ -837,14 +926,9 @@ embedding_bag
   -> Int -- ^ mode
   -> Bool -- ^ sparse
   -> Tensor -- ^ per_sample_weights
+  -> Bool -- ^ include_last_offset
   -> (Tensor,Tensor,Tensor,Tensor)
-embedding_bag _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights = unsafePerformIO $ (cast7 ATen.embedding_bag_tttblbt) _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights
-
-emptyLikeWithMemoryFormat
-  :: Tensor -- ^ self
-  -> ATen.MemoryFormat -- ^ memory_format
-  -> Tensor
-emptyLikeWithMemoryFormat _self _memory_format = unsafePerformIO $ (cast2 ATen.empty_like_tM) _self _memory_format
+embedding_bag _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset = unsafePerformIO $ (cast8 ATen.embedding_bag_tttblbtb) _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset
 
 erf
   :: Tensor -- ^ self
@@ -901,17 +985,22 @@ floor
   -> Tensor
 floor _self = unsafePerformIO $ (cast1 ATen.floor_t) _self
 
-frac
+floor_divide_tt
   :: Tensor -- ^ self
+  -> Tensor -- ^ other
   -> Tensor
-frac _self = unsafePerformIO $ (cast1 ATen.frac_t) _self
+floor_divide_tt _self _other = unsafePerformIO $ (cast2 ATen.floor_divide_tt) _self _other
 
-fullLikeWithMemoryFormat
+floor_divide_ts
   :: Tensor -- ^ self
-  -> Float -- ^ fill_value
-  -> ATen.MemoryFormat -- ^ memory_format
+  -> Float -- ^ other
   -> Tensor
-fullLikeWithMemoryFormat _self _fill_value _memory_format = unsafePerformIO $ (cast3 ATen.full_like_tsM) _self _fill_value _memory_format
+floor_divide_ts _self _other = unsafePerformIO $ (cast2 ATen.floor_divide_ts) _self _other
+
+frac
+  :: Tensor -- ^ self
+  -> Tensor
+frac _self = unsafePerformIO $ (cast1 ATen.frac_t) _self
 
 grid_sampler
   :: Tensor -- ^ input
@@ -1805,13 +1894,21 @@ mvlgamma
   -> Tensor
 mvlgamma _self _p = unsafePerformIO $ (cast2 ATen.mvlgamma_tl) _self _p
 
-narrow
+narrow_tlll
   :: Tensor -- ^ self
   -> Int -- ^ dim
   -> Int -- ^ start
   -> Int -- ^ length
   -> Tensor
-narrow _self _dim _start _length = unsafePerformIO $ (cast4 ATen.narrow_tlll) _self _dim _start _length
+narrow_tlll _self _dim _start _length = unsafePerformIO $ (cast4 ATen.narrow_tlll) _self _dim _start _length
+
+narrow_tltl
+  :: Tensor -- ^ self
+  -> Int -- ^ dim
+  -> Tensor -- ^ start
+  -> Int -- ^ length
+  -> Tensor
+narrow_tltl _self _dim _start _length = unsafePerformIO $ (cast4 ATen.narrow_tltl) _self _dim _start _length
 
 native_batch_norm
   :: Tensor -- ^ input
@@ -1910,12 +2007,6 @@ batch_norm_update_stats
   -> (Tensor,Tensor)
 batch_norm_update_stats _input _running_mean _running_var _momentum = unsafePerformIO $ (cast4 ATen.batch_norm_update_stats_tttd) _input _running_mean _running_var _momentum
 
-onesLikeWithMemoryFormat
-  :: Tensor -- ^ self
-  -> ATen.MemoryFormat -- ^ memory_format
-  -> Tensor
-onesLikeWithMemoryFormat _self _memory_format = unsafePerformIO $ (cast2 ATen.ones_like_tM) _self _memory_format
-
 pairwise_distance
   :: Tensor -- ^ x1
   -> Tensor -- ^ x2
@@ -1969,33 +2060,6 @@ poisson_nll_loss
   -> Tensor
 poisson_nll_loss _input _target _log_input _full _eps _reduction = unsafePerformIO $ (cast6 ATen.poisson_nll_loss_ttbbdl) _input _target _log_input _full _eps _reduction
 
-randLikeWithMemoryFormat
-  :: Tensor -- ^ self
-  -> ATen.MemoryFormat -- ^ memory_format
-  -> Tensor
-randLikeWithMemoryFormat _self _memory_format = unsafePerformIO $ (cast2 ATen.rand_like_tM) _self _memory_format
-
-randintLike'
-  :: Tensor -- ^ self
-  -> Int -- ^ high
-  -> ATen.MemoryFormat -- ^ memory_format
-  -> Tensor
-randintLike' _self _high _memory_format = unsafePerformIO $ (cast3 ATen.randint_like_tlM) _self _high _memory_format
-
-randintLike
-  :: Tensor -- ^ self
-  -> Int -- ^ low
-  -> Int -- ^ high
-  -> ATen.MemoryFormat -- ^ memory_format
-  -> Tensor
-randintLike _self _low _high _memory_format = unsafePerformIO $ (cast4 ATen.randint_like_tllM) _self _low _high _memory_format
-
-randnLikeWithMemoryFormat
-  :: Tensor -- ^ self
-  -> ATen.MemoryFormat -- ^ memory_format
-  -> Tensor
-randnLikeWithMemoryFormat _self _memory_format = unsafePerformIO $ (cast2 ATen.randn_like_tM) _self _memory_format
-
 reciprocal
   :: Tensor -- ^ self
   -> Tensor
@@ -2265,6 +2329,11 @@ sqrt
   -> Tensor
 sqrt _self = unsafePerformIO $ (cast1 ATen.sqrt_t) _self
 
+square
+  :: Tensor -- ^ self
+  -> Tensor
+square _self = unsafePerformIO $ (cast1 ATen.square_t) _self
+
 stdAll
   :: Tensor -- ^ self
   -> Bool -- ^ unbiased
@@ -2434,6 +2503,18 @@ triplet_margin_loss
   -> Tensor
 triplet_margin_loss _anchor _positive _negative _margin _p _eps _swap _reduction = unsafePerformIO $ (cast8 ATen.triplet_margin_loss_tttdddbl) _anchor _positive _negative _margin _p _eps _swap _reduction
 
+true_divide_tt
+  :: Tensor -- ^ self
+  -> Tensor -- ^ other
+  -> Tensor
+true_divide_tt _self _other = unsafePerformIO $ (cast2 ATen.true_divide_tt) _self _other
+
+true_divide_ts
+  :: Tensor -- ^ self
+  -> Float -- ^ other
+  -> Tensor
+true_divide_ts _self _other = unsafePerformIO $ (cast2 ATen.true_divide_ts) _self _other
+
 trunc
   :: Tensor -- ^ self
   -> Tensor
@@ -2533,12 +2614,6 @@ norm_except_dim
   -> Tensor
 norm_except_dim _v _pow _dim = unsafePerformIO $ (cast3 ATen.norm_except_dim_tll) _v _pow _dim
 
-zerosLikeWithMemoryFormat
-  :: Tensor -- ^ self
-  -> ATen.MemoryFormat -- ^ memory_format
-  -> Tensor
-zerosLikeWithMemoryFormat _self _memory_format = unsafePerformIO $ (cast2 ATen.zeros_like_tM) _self _memory_format
-
 native_norm
   :: Tensor -- ^ self
   -> Float -- ^ p
@@ -3239,6 +3314,30 @@ scatterAddWithDimname
   -> Tensor
 scatterAddWithDimname _self _dim _index _src = unsafePerformIO $ (cast4 ATen.scatter_add_tntt) _self _dim _index _src
 
+bitwise_and_ts
+  :: Tensor -- ^ self
+  -> Float -- ^ other
+  -> Tensor
+bitwise_and_ts _self _other = unsafePerformIO $ (cast2 ATen.bitwise_and_ts) _self _other
+
+bitwise_and_tt
+  :: Tensor -- ^ self
+  -> Tensor -- ^ other
+  -> Tensor
+bitwise_and_tt _self _other = unsafePerformIO $ (cast2 ATen.bitwise_and_tt) _self _other
+
+bitwise_or_ts
+  :: Tensor -- ^ self
+  -> Float -- ^ other
+  -> Tensor
+bitwise_or_ts _self _other = unsafePerformIO $ (cast2 ATen.bitwise_or_ts) _self _other
+
+bitwise_or_tt
+  :: Tensor -- ^ self
+  -> Tensor -- ^ other
+  -> Tensor
+bitwise_or_tt _self _other = unsafePerformIO $ (cast2 ATen.bitwise_or_tt) _self _other
+
 bitwiseXorScalar
   :: Tensor -- ^ self
   -> Float -- ^ other
@@ -3713,23 +3812,6 @@ alias
   -> Tensor
 alias _self = unsafePerformIO $ (cast1 ATen.alias_t) _self
 
-binary_cross_entropy
-  :: Tensor -- ^ self
-  -> Tensor -- ^ target
-  -> Tensor -- ^ weight
-  -> Int -- ^ reduction
-  -> Tensor
-binary_cross_entropy _self _target _weight _reduction = unsafePerformIO $ (cast4 ATen.binary_cross_entropy_tttl) _self _target _weight _reduction
-
-binary_cross_entropy_backward
-  :: Tensor -- ^ grad_output
-  -> Tensor -- ^ self
-  -> Tensor -- ^ target
-  -> Tensor -- ^ weight
-  -> Int -- ^ reduction
-  -> Tensor
-binary_cross_entropy_backward _grad_output _self _target _weight _reduction = unsafePerformIO $ (cast5 ATen.binary_cross_entropy_backward_ttttl) _grad_output _self _target _weight _reduction
-
 mse_loss
   :: Tensor -- ^ self
   -> Tensor -- ^ target
@@ -3922,6 +4004,17 @@ glu_backward
   -> Tensor
 glu_backward _grad_output _self _dim = unsafePerformIO $ (cast3 ATen.glu_backward_ttl) _grad_output _self _dim
 
+hardsigmoid
+  :: Tensor -- ^ self
+  -> Tensor
+hardsigmoid _self = unsafePerformIO $ (cast1 ATen.hardsigmoid_t) _self
+
+hardsigmoid_backward
+  :: Tensor -- ^ grad_output
+  -> Tensor -- ^ self
+  -> Tensor
+hardsigmoid_backward _grad_output _self = unsafePerformIO $ (cast2 ATen.hardsigmoid_backward_tt) _grad_output _self
+
 hardtanh
   :: Tensor -- ^ self
   -> Float -- ^ min_val
@@ -3947,8 +4040,9 @@ leaky_relu_backward
   :: Tensor -- ^ grad_output
   -> Tensor -- ^ self
   -> Float -- ^ negative_slope
+  -> Bool -- ^ self_is_result
   -> Tensor
-leaky_relu_backward _grad_output _self _negative_slope = unsafePerformIO $ (cast3 ATen.leaky_relu_backward_tts) _grad_output _self _negative_slope
+leaky_relu_backward _grad_output _self _negative_slope _self_is_result = unsafePerformIO $ (cast4 ATen.leaky_relu_backward_ttsb) _grad_output _self _negative_slope _self_is_result
 
 log_sigmoid
   :: Tensor -- ^ self
@@ -3974,8 +4068,9 @@ rrelu_with_noise_backward
   -> Float -- ^ lower
   -> Float -- ^ upper
   -> Bool -- ^ training
+  -> Bool -- ^ self_is_result
   -> Tensor
-rrelu_with_noise_backward _grad_output _self _noise _lower _upper _training = unsafePerformIO $ (cast6 ATen.rrelu_with_noise_backward_tttssb) _grad_output _self _noise _lower _upper _training
+rrelu_with_noise_backward _grad_output _self _noise _lower _upper _training _self_is_result = unsafePerformIO $ (cast7 ATen.rrelu_with_noise_backward_tttssbb) _grad_output _self _noise _lower _upper _training _self_is_result
 
 softplus
   :: Tensor -- ^ self
@@ -4283,21 +4378,25 @@ upsample_linear1d
   :: Tensor -- ^ self
   -> Int -- ^ output_size
   -> Bool -- ^ align_corners
+  -> Double -- ^ scales
   -> Tensor
-upsample_linear1d _self _output_size _align_corners = unsafePerformIO $ (cast3 ATen.upsample_linear1d_tlb) _self _output_size _align_corners
+upsample_linear1d _self _output_size _align_corners _scales = unsafePerformIO $ (cast4 ATen.upsample_linear1d_tlbd) _self _output_size _align_corners _scales
 
 upsample_linear1d_backward
   :: Tensor -- ^ grad_output
   -> Int -- ^ output_size
   -> (Int,Int,Int) -- ^ input_size
   -> Bool -- ^ align_corners
+  -> Double -- ^ scales
   -> Tensor
-upsample_linear1d_backward _grad_output _output_size _input_size _align_corners = unsafePerformIO $ (cast4 ATen.upsample_linear1d_backward_tllb) _grad_output _output_size _input_size _align_corners
+upsample_linear1d_backward _grad_output _output_size _input_size _align_corners _scales = unsafePerformIO $ (cast5 ATen.upsample_linear1d_backward_tllbd) _grad_output _output_size _input_size _align_corners _scales
 
 upsample_bilinear2d
   :: Tensor -- ^ self
   -> (Int,Int) -- ^ output_size
   -> Bool -- ^ align_corners
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
 upsample_bilinear2d _self (height, width) _align_corners = unsafePerformIO $ (cast3 ATen.upsample_bilinear2d_tlb) _self [height, width] _align_corners
 
@@ -4306,77 +4405,101 @@ upsample_bilinear2d_backward
   -> (Int,Int) -- ^ output_size
   -> (Int,Int,Int,Int) -- ^ input_size
   -> Bool -- ^ align_corners
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_bilinear2d_backward _grad_output _output_size _input_size _align_corners = unsafePerformIO $ (cast4 ATen.upsample_bilinear2d_backward_tllb) _grad_output _output_size _input_size _align_corners
+upsample_bilinear2d_backward _grad_output _output_size _input_size _align_corners _scales_h _scales_w = unsafePerformIO $ (cast6 ATen.upsample_bilinear2d_backward_tllbdd) _grad_output _output_size _input_size _align_corners _scales_h _scales_w
 
 upsample_bicubic2d
   :: Tensor -- ^ self
   -> (Int,Int) -- ^ output_size
   -> Bool -- ^ align_corners
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_bicubic2d _self _output_size _align_corners = unsafePerformIO $ (cast3 ATen.upsample_bicubic2d_tlb) _self _output_size _align_corners
+upsample_bicubic2d _self _output_size _align_corners _scales_h _scales_w = unsafePerformIO $ (cast5 ATen.upsample_bicubic2d_tlbdd) _self _output_size _align_corners _scales_h _scales_w
 
 upsample_bicubic2d_backward
   :: Tensor -- ^ grad_output
   -> (Int,Int) -- ^ output_size
   -> (Int,Int,Int,Int) -- ^ input_size
   -> Bool -- ^ align_corners
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_bicubic2d_backward _grad_output _output_size _input_size _align_corners = unsafePerformIO $ (cast4 ATen.upsample_bicubic2d_backward_tllb) _grad_output _output_size _input_size _align_corners
+upsample_bicubic2d_backward _grad_output _output_size _input_size _align_corners _scales_h _scales_w = unsafePerformIO $ (cast6 ATen.upsample_bicubic2d_backward_tllbdd) _grad_output _output_size _input_size _align_corners _scales_h _scales_w
 
 upsample_trilinear3d
   :: Tensor -- ^ self
   -> (Int,Int,Int) -- ^ output_size
   -> Bool -- ^ align_corners
+  -> Double -- ^ scales_d
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_trilinear3d _self _output_size _align_corners = unsafePerformIO $ (cast3 ATen.upsample_trilinear3d_tlb) _self _output_size _align_corners
+upsample_trilinear3d _self _output_size _align_corners _scales_d _scales_h _scales_w = unsafePerformIO $ (cast6 ATen.upsample_trilinear3d_tlbddd) _self _output_size _align_corners _scales_d _scales_h _scales_w
 
 upsample_trilinear3d_backward
   :: Tensor -- ^ grad_output
   -> (Int,Int,Int) -- ^ output_size
   -> (Int,Int,Int,Int,Int) -- ^ input_size
   -> Bool -- ^ align_corners
+  -> Double -- ^ scales_d
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_trilinear3d_backward _grad_output _output_size _input_size _align_corners = unsafePerformIO $ (cast4 ATen.upsample_trilinear3d_backward_tllb) _grad_output _output_size _input_size _align_corners
+upsample_trilinear3d_backward _grad_output _output_size _input_size _align_corners _scales_d _scales_h _scales_w = unsafePerformIO $ (cast7 ATen.upsample_trilinear3d_backward_tllbddd) _grad_output _output_size _input_size _align_corners _scales_d _scales_h _scales_w
 
 upsample_nearest1d
   :: Tensor -- ^ self
   -> Int -- ^ output_size
+  -> Double -- ^ scales
   -> Tensor
-upsample_nearest1d _self _output_size = unsafePerformIO $ (cast2 ATen.upsample_nearest1d_tl) _self _output_size
+upsample_nearest1d _self _output_size _scales = unsafePerformIO $ (cast3 ATen.upsample_nearest1d_tld) _self _output_size _scales
 
 upsample_nearest1d_backward
   :: Tensor -- ^ grad_output
   -> Int -- ^ output_size
   -> (Int,Int,Int) -- ^ input_size
+  -> Double -- ^ scales
   -> Tensor
-upsample_nearest1d_backward _grad_output _output_size _input_size = unsafePerformIO $ (cast3 ATen.upsample_nearest1d_backward_tll) _grad_output _output_size _input_size
+upsample_nearest1d_backward _grad_output _output_size _input_size _scales = unsafePerformIO $ (cast4 ATen.upsample_nearest1d_backward_tlld) _grad_output _output_size _input_size _scales
 
 upsample_nearest2d
   :: Tensor -- ^ self
   -> (Int,Int) -- ^ output_size
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_nearest2d _self _output_size = unsafePerformIO $ (cast2 ATen.upsample_nearest2d_tl) _self _output_size
+upsample_nearest2d _self _output_size _scales_h _scales_w = unsafePerformIO $ (cast4 ATen.upsample_nearest2d_tldd) _self _output_size _scales_h _scales_w
 
 upsample_nearest2d_backward
   :: Tensor -- ^ grad_output
   -> (Int,Int) -- ^ output_size
   -> (Int,Int,Int,Int) -- ^ input_size
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_nearest2d_backward _grad_output _output_size _input_size = unsafePerformIO $ (cast3 ATen.upsample_nearest2d_backward_tll) _grad_output _output_size _input_size
+upsample_nearest2d_backward _grad_output _output_size _input_size _scales_h _scales_w = unsafePerformIO $ (cast5 ATen.upsample_nearest2d_backward_tlldd) _grad_output _output_size _input_size _scales_h _scales_w
 
 upsample_nearest3d
   :: Tensor -- ^ self
   -> (Int,Int,Int) -- ^ output_size
+  -> Double -- ^ scales_d
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_nearest3d _self _output_size = unsafePerformIO $ (cast2 ATen.upsample_nearest3d_tl) _self _output_size
+upsample_nearest3d _self _output_size _scales_d _scales_h _scales_w = unsafePerformIO $ (cast5 ATen.upsample_nearest3d_tlddd) _self _output_size _scales_d _scales_h _scales_w
 
 upsample_nearest3d_backward
   :: Tensor -- ^ grad_output
   -> (Int,Int,Int) -- ^ output_size
   -> (Int,Int,Int,Int,Int) -- ^ input_size
+  -> Double -- ^ scales_d
+  -> Double -- ^ scales_h
+  -> Double -- ^ scales_w
   -> Tensor
-upsample_nearest3d_backward _grad_output _output_size _input_size = unsafePerformIO $ (cast3 ATen.upsample_nearest3d_backward_tll) _grad_output _output_size _input_size
+upsample_nearest3d_backward _grad_output _output_size _input_size _scales_d _scales_h _scales_w = unsafePerformIO $ (cast6 ATen.upsample_nearest3d_backward_tllddd) _grad_output _output_size _input_size _scales_d _scales_h _scales_w
 
 sigmoid_backward
   :: Tensor -- ^ grad_output
@@ -4633,3 +4756,8 @@ isfinite
   -> Tensor
 isfinite _self = unsafePerformIO $ (cast1 ATen.isfinite_t) _self
 
+isinf
+  :: Tensor -- ^ self
+  -> Tensor
+isinf _self = unsafePerformIO $ (cast1 ATen.isinf_t) _self
+
diff --git a/hasktorch/src/Torch/Script.hs b/hasktorch/src/Torch/Script.hs
index 5d8072e94..bf591f007 100644
--- a/hasktorch/src/Torch/Script.hs
+++ b/hasktorch/src/Torch/Script.hs
@@ -444,7 +444,7 @@ instance Castable IValue RawIValue where
            ts <- uncast rawIValues return :: IO [IValue]
            f (IVTuple ts)
         )
-      , (iValue_isGenericList obj, do
+      , (iValue_isList obj, do
            c10list <- fromIValue obj :: IO (ForeignPtr (ATen.C10List ATen.IValue))
            rawIValues <- uncast c10list return :: IO [RawIValue]
            ts <- uncast rawIValues return :: IO [IValue]
diff --git a/libtorch-ffi-helper/libtorch-ffi-helper.cabal b/libtorch-ffi-helper/libtorch-ffi-helper.cabal
index efe680941..14b5da29e 100644
--- a/libtorch-ffi-helper/libtorch-ffi-helper.cabal
+++ b/libtorch-ffi-helper/libtorch-ffi-helper.cabal
@@ -1,7 +1,7 @@
 cabal-version:       2.1
 name:                libtorch-ffi-helper
-version:             1.4.0.0
--- The prefix(1.4) of this version("1.4.0.0") is the same as libtorch's one.
+version:             1.5.0.0
+-- The prefix(1.5) of this version("1.5.0.0") is the same as libtorch's one.
 synopsis:            ffi-wrapper for macos
 -- description:
 homepage:            https://github.com/hasktorch/hasktorch#readme
diff --git a/libtorch-ffi/libtorch-ffi.cabal b/libtorch-ffi/libtorch-ffi.cabal
index 1c332ab7d..4d750b2cd 100644
--- a/libtorch-ffi/libtorch-ffi.cabal
+++ b/libtorch-ffi/libtorch-ffi.cabal
@@ -1,7 +1,7 @@
 cabal-version:       2.1
 name:                libtorch-ffi
-version:             1.4.0.0
--- The prefix(1.4) of this version("1.4.0.0") is the same as libtorch's one.
+version:             1.5.0.0
+-- The prefix(1.5) of this version("1.5.0.0") is the same as libtorch's one.
 synopsis:            test out alternative options for ffi interface to libtorch 1.x
 -- description:
 homepage:            https://github.com/hasktorch/hasktorch#readme
@@ -12,6 +12,16 @@ copyright:           2018 Austin Huang
 category:            Codegen
 build-type:          Simple
 
+Flag cuda
+ Description: A flag to link libtorch_cuda.
+ Default: False
+ Manual: True
+
+Flag gcc
+ Description: A flag to use gcc on macos
+ Default: False
+ Manual: True
+
 library
  exposed-modules:     Torch.Internal.Type
                     , Torch.Internal.Const
@@ -84,22 +94,22 @@ library
                     , sysinfo
                     , async
                     , libtorch-ffi-helper
+ extra-libraries:     c10
+                    , torch
+                    , torch_cpu
  if os(darwin)
   extra-libraries:     c++
-                     , c10
-                     , torch
  else
   extra-libraries:     stdc++
-                     , c10
-                     , torch
+
+ if flag(cuda)
+  extra-libraries:     torch_cuda
+
  extra-ghci-libraries: stdc++
  if os(darwin)
   ld-options: -Wl,-keep_dwarf_unwind
-  ghc-options:       -optc-std=c++11 -optc-xc++
- else
-  ghc-options:       -optc-std=c++11
-  cc-options:        -std=c++11
- cxx-options:       -std=c++11
+  if !flag(gcc)
+    ghc-options:       -optc-std=c++14 -optc-xc++
  default-extensions:          Strict
                             , StrictData
 
diff --git a/libtorch-ffi/src/Torch/Internal/Managed/Native.hs b/libtorch-ffi/src/Torch/Internal/Managed/Native.hs
index 30fb97028..cb97ca6cc 100644
--- a/libtorch-ffi/src/Torch/Internal/Managed/Native.hs
+++ b/libtorch-ffi/src/Torch/Internal/Managed/Native.hs
@@ -365,23 +365,11 @@ real_t
   -> IO (ForeignPtr Tensor)
 real_t = cast1 Unmanaged.real_t
 
-real_out_tt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-real_out_tt = cast2 Unmanaged.real_out_tt
-
 imag_t
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
 imag_t = cast1 Unmanaged.imag_t
 
-imag_out_tt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-imag_out_tt = cast2 Unmanaged.imag_out_tt
-
 conj_t
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
@@ -1060,6 +1048,18 @@ batch_norm_tttttbddb
   -> IO (ForeignPtr Tensor)
 batch_norm_tttttbddb = cast9 Unmanaged.batch_norm_tttttbddb
 
+quantized_batch_norm_tttttddl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+quantized_batch_norm_tttttddl = cast8 Unmanaged.quantized_batch_norm_tttttddl
+
 _batch_norm_impl_index_tttttbddb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -1134,6 +1134,102 @@ bilinear_tttt
   -> IO (ForeignPtr Tensor)
 bilinear_tttt = cast4 Unmanaged.bilinear_tttt
 
+binary_cross_entropy_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_tttl = cast4 Unmanaged.binary_cross_entropy_tttl
+
+binary_cross_entropy_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_ttt = cast3 Unmanaged.binary_cross_entropy_ttt
+
+binary_cross_entropy_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_tt = cast2 Unmanaged.binary_cross_entropy_tt
+
+binary_cross_entropy_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_out_ttttl = cast5 Unmanaged.binary_cross_entropy_out_ttttl
+
+binary_cross_entropy_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_out_tttt = cast4 Unmanaged.binary_cross_entropy_out_tttt
+
+binary_cross_entropy_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_out_ttt = cast3 Unmanaged.binary_cross_entropy_out_ttt
+
+binary_cross_entropy_backward_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_backward_ttttl = cast5 Unmanaged.binary_cross_entropy_backward_ttttl
+
+binary_cross_entropy_backward_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_backward_tttt = cast4 Unmanaged.binary_cross_entropy_backward_tttt
+
+binary_cross_entropy_backward_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_backward_ttt = cast3 Unmanaged.binary_cross_entropy_backward_ttt
+
+binary_cross_entropy_backward_out_tttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_backward_out_tttttl = cast6 Unmanaged.binary_cross_entropy_backward_out_tttttl
+
+binary_cross_entropy_backward_out_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_backward_out_ttttt = cast5 Unmanaged.binary_cross_entropy_backward_out_ttttt
+
+binary_cross_entropy_backward_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_backward_out_tttt = cast4 Unmanaged.binary_cross_entropy_backward_out_tttt
+
 binary_cross_entropy_with_logits_ttttl
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -1251,6 +1347,32 @@ logical_xor_out_ttt
   -> IO (ForeignPtr Tensor)
 logical_xor_out_ttt = cast3 Unmanaged.logical_xor_out_ttt
 
+logical_and_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logical_and_tt = cast2 Unmanaged.logical_and_tt
+
+logical_and_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logical_and_out_ttt = cast3 Unmanaged.logical_and_out_ttt
+
+logical_or_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logical_or_tt = cast2 Unmanaged.logical_or_tt
+
+logical_or_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logical_or_out_ttt = cast3 Unmanaged.logical_or_out_ttt
+
 blackman_window_lo
   :: Int64
   -> ForeignPtr TensorOptions
@@ -2056,6 +2178,18 @@ cudnn_convolution_tttllllbb
   -> IO (ForeignPtr Tensor)
 cudnn_convolution_tttllllbb = cast9 Unmanaged.cudnn_convolution_tttllllbb
 
+cudnn_convolution_ttllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_ttllllbb = cast8 Unmanaged.cudnn_convolution_ttllllbb
+
 cudnn_convolution_backward_input_lttllllbb
   :: ForeignPtr IntArray
   -> ForeignPtr Tensor
@@ -2079,15 +2213,10 @@ cudnn_convolution_backward_tttllllbba
   -> Int64
   -> CBool
   -> CBool
-  -> ForeignPtr (StdArray '(CBool,3))
-  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
 cudnn_convolution_backward_tttllllbba = cast10 Unmanaged.cudnn_convolution_backward_tttllllbba
 
-cudnn_convolution_backward_bias_t
-  :: ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-cudnn_convolution_backward_bias_t = cast1 Unmanaged.cudnn_convolution_backward_bias_t
-
 cudnn_convolution_backward_weight_lttllllbb
   :: ForeignPtr IntArray
   -> ForeignPtr Tensor
@@ -2115,6 +2244,19 @@ cudnn_convolution_transpose_tttlllllbb
   -> IO (ForeignPtr Tensor)
 cudnn_convolution_transpose_tttlllllbb = cast10 Unmanaged.cudnn_convolution_transpose_tttlllllbb
 
+cudnn_convolution_transpose_ttlllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_transpose_ttlllllbb = cast9 Unmanaged.cudnn_convolution_transpose_ttlllllbb
+
 cudnn_convolution_transpose_backward_tttlllllbba
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -2126,15 +2268,10 @@ cudnn_convolution_transpose_backward_tttlllllbba
   -> Int64
   -> CBool
   -> CBool
-  -> ForeignPtr (StdArray '(CBool,3))
-  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
 cudnn_convolution_transpose_backward_tttlllllbba = cast11 Unmanaged.cudnn_convolution_transpose_backward_tttlllllbba
 
-cudnn_convolution_transpose_backward_bias_t
-  :: ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-cudnn_convolution_transpose_backward_bias_t = cast1 Unmanaged.cudnn_convolution_transpose_backward_bias_t
-
 cudnn_convolution_transpose_backward_input_ttllllbb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -2173,61 +2310,77 @@ cudnn_grid_sampler_backward_ttt
   -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
 cudnn_grid_sampler_backward_ttt = cast3 Unmanaged.cudnn_grid_sampler_backward_ttt
 
-cumsum_tls
+cummax_tl
   :: ForeignPtr Tensor
   -> Int64
-  -> ScalarType
-  -> IO (ForeignPtr Tensor)
-cumsum_tls = cast3 Unmanaged.cumsum_tls
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummax_tl = cast2 Unmanaged.cummax_tl
 
-cumsum_tl
+cummax_out_tttl
   :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
   -> Int64
-  -> IO (ForeignPtr Tensor)
-cumsum_tl = cast2 Unmanaged.cumsum_tl
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummax_out_tttl = cast4 Unmanaged.cummax_out_tttl
 
-cumsum_out_ttls
+cummax_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummax_tn = cast2 Unmanaged.cummax_tn
+
+cummax_out_tttn
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
-  -> Int64
-  -> ScalarType
-  -> IO (ForeignPtr Tensor)
-cumsum_out_ttls = cast4 Unmanaged.cumsum_out_ttls
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummax_out_tttn = cast4 Unmanaged.cummax_out_tttn
 
-cumsum_out_ttl
+_cummax_helper_tttl
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
   -> Int64
-  -> IO (ForeignPtr Tensor)
-cumsum_out_ttl = cast3 Unmanaged.cumsum_out_ttl
+  -> IO (())
+_cummax_helper_tttl = cast4 Unmanaged._cummax_helper_tttl
 
-cumsum_tns
+cummin_tl
   :: ForeignPtr Tensor
-  -> ForeignPtr Dimname
-  -> ScalarType
-  -> IO (ForeignPtr Tensor)
-cumsum_tns = cast3 Unmanaged.cumsum_tns
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummin_tl = cast2 Unmanaged.cummin_tl
 
-cumsum_tn
+cummin_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummin_out_tttl = cast4 Unmanaged.cummin_out_tttl
+
+cummin_tn
   :: ForeignPtr Tensor
   -> ForeignPtr Dimname
-  -> IO (ForeignPtr Tensor)
-cumsum_tn = cast2 Unmanaged.cumsum_tn
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummin_tn = cast2 Unmanaged.cummin_tn
 
-cumsum_out_ttns
+cummin_out_tttn
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
   -> ForeignPtr Dimname
-  -> ScalarType
-  -> IO (ForeignPtr Tensor)
-cumsum_out_ttns = cast4 Unmanaged.cumsum_out_ttns
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummin_out_tttn = cast4 Unmanaged.cummin_out_tttn
 
-cumsum_out_ttn
+_cummin_helper_tttl
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
-  -> ForeignPtr Dimname
-  -> IO (ForeignPtr Tensor)
-cumsum_out_ttn = cast3 Unmanaged.cumsum_out_ttn
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (())
+_cummin_helper_tttl = cast4 Unmanaged._cummin_helper_tttl
 
 cumprod_tls
   :: ForeignPtr Tensor
@@ -2285,43 +2438,99 @@ cumprod_out_ttn
   -> IO (ForeignPtr Tensor)
 cumprod_out_ttn = cast3 Unmanaged.cumprod_out_ttn
 
-ctc_loss_ttllllb
+cumsum_tls
   :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr IntArray
-  -> ForeignPtr IntArray
   -> Int64
-  -> Int64
-  -> CBool
+  -> ScalarType
   -> IO (ForeignPtr Tensor)
-ctc_loss_ttllllb = cast7 Unmanaged.ctc_loss_ttllllb
+cumsum_tls = cast3 Unmanaged.cumsum_tls
 
-ctc_loss_ttllll
+cumsum_tl
   :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr IntArray
-  -> ForeignPtr IntArray
-  -> Int64
   -> Int64
   -> IO (ForeignPtr Tensor)
-ctc_loss_ttllll = cast6 Unmanaged.ctc_loss_ttllll
+cumsum_tl = cast2 Unmanaged.cumsum_tl
 
-ctc_loss_ttlll
+cumsum_out_ttls
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
-  -> ForeignPtr IntArray
-  -> ForeignPtr IntArray
   -> Int64
+  -> ScalarType
   -> IO (ForeignPtr Tensor)
-ctc_loss_ttlll = cast5 Unmanaged.ctc_loss_ttlll
+cumsum_out_ttls = cast4 Unmanaged.cumsum_out_ttls
 
-ctc_loss_ttll
+cumsum_out_ttl
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
-  -> ForeignPtr IntArray
-  -> ForeignPtr IntArray
+  -> Int64
   -> IO (ForeignPtr Tensor)
-ctc_loss_ttll = cast4 Unmanaged.ctc_loss_ttll
+cumsum_out_ttl = cast3 Unmanaged.cumsum_out_ttl
+
+cumsum_tns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+cumsum_tns = cast3 Unmanaged.cumsum_tns
+
+cumsum_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+cumsum_tn = cast2 Unmanaged.cumsum_tn
+
+cumsum_out_ttns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+cumsum_out_ttns = cast4 Unmanaged.cumsum_out_ttns
+
+cumsum_out_ttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+cumsum_out_ttn = cast3 Unmanaged.cumsum_out_ttn
+
+ctc_loss_ttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+ctc_loss_ttllllb = cast7 Unmanaged.ctc_loss_ttllllb
+
+ctc_loss_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+ctc_loss_ttllll = cast6 Unmanaged.ctc_loss_ttllll
+
+ctc_loss_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+ctc_loss_ttlll = cast5 Unmanaged.ctc_loss_ttlll
+
+ctc_loss_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+ctc_loss_ttll = cast4 Unmanaged.ctc_loss_ttll
 
 ctc_loss_ttttllb
   :: ForeignPtr Tensor
@@ -2481,6 +2690,23 @@ diagonal_t
   -> IO (ForeignPtr Tensor)
 diagonal_t = cast1 Unmanaged.diagonal_t
 
+diagonal_tnnnl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_tnnnl = cast5 Unmanaged.diagonal_tnnnl
+
+diagonal_tnnn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+diagonal_tnnn = cast4 Unmanaged.diagonal_tnnn
+
 div_tt
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -2585,6 +2811,18 @@ embedding_sparse_backward_ttllb
   -> IO (ForeignPtr Tensor)
 embedding_sparse_backward_ttllb = cast5 Unmanaged.embedding_sparse_backward_ttllb
 
+embedding_bag_tttblbtb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttblbtb = cast8 Unmanaged.embedding_bag_tttblbtb
+
 embedding_bag_tttblbt
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -2630,6 +2868,18 @@ embedding_bag_ttt
   -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
 embedding_bag_ttt = cast3 Unmanaged.embedding_bag_ttt
 
+_embedding_bag_tttblbtb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttblbtb = cast8 Unmanaged._embedding_bag_tttblbtb
+
 _embedding_bag_tttblbt
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -2841,17 +3091,6 @@ empty_out_tl
   -> IO (ForeignPtr Tensor)
 empty_out_tl = cast2 Unmanaged.empty_out_tl
 
-empty_like_tM
-  :: ForeignPtr Tensor
-  -> MemoryFormat
-  -> IO (ForeignPtr Tensor)
-empty_like_tM = cast2 Unmanaged.empty_like_tM
-
-empty_like_t
-  :: ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-empty_like_t = cast1 Unmanaged.empty_like_t
-
 empty_like_toM
   :: ForeignPtr Tensor
   -> ForeignPtr TensorOptions
@@ -2865,6 +3104,11 @@ empty_like_to
   -> IO (ForeignPtr Tensor)
 empty_like_to = cast2 Unmanaged.empty_like_to
 
+empty_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+empty_like_t = cast1 Unmanaged.empty_like_t
+
 empty_strided_llo
   :: ForeignPtr IntArray
   -> ForeignPtr IntArray
@@ -3048,6 +3292,25 @@ floor_out_tt
   -> IO (ForeignPtr Tensor)
 floor_out_tt = cast2 Unmanaged.floor_out_tt
 
+floor_divide_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+floor_divide_tt = cast2 Unmanaged.floor_divide_tt
+
+floor_divide_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+floor_divide_out_ttt = cast3 Unmanaged.floor_divide_out_ttt
+
+floor_divide_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+floor_divide_ts = cast2 Unmanaged.floor_divide_ts
+
 frac_t
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
@@ -3099,19 +3362,6 @@ full_out_tls
   -> IO (ForeignPtr Tensor)
 full_out_tls = cast3 Unmanaged.full_out_tls
 
-full_like_tsM
-  :: ForeignPtr Tensor
-  -> ForeignPtr Scalar
-  -> MemoryFormat
-  -> IO (ForeignPtr Tensor)
-full_like_tsM = cast3 Unmanaged.full_like_tsM
-
-full_like_ts
-  :: ForeignPtr Tensor
-  -> ForeignPtr Scalar
-  -> IO (ForeignPtr Tensor)
-full_like_ts = cast2 Unmanaged.full_like_ts
-
 full_like_tsoM
   :: ForeignPtr Tensor
   -> ForeignPtr Scalar
@@ -3127,6 +3377,12 @@ full_like_tso
   -> IO (ForeignPtr Tensor)
 full_like_tso = cast3 Unmanaged.full_like_tso
 
+full_like_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+full_like_ts = cast2 Unmanaged.full_like_ts
+
 from_file_sblo
   :: ForeignPtr StdString
   -> CBool
@@ -5204,6 +5460,14 @@ narrow_tlll
   -> IO (ForeignPtr Tensor)
 narrow_tlll = cast4 Unmanaged.narrow_tlll
 
+narrow_tltl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+narrow_tltl = cast4 Unmanaged.narrow_tltl
+
 native_batch_norm_tttttbdd
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -5216,6 +5480,21 @@ native_batch_norm_tttttbdd
   -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
 native_batch_norm_tttttbdd = cast8 Unmanaged.native_batch_norm_tttttbdd
 
+native_batch_norm_out_ttttttttbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_batch_norm_out_ttttttttbdd = cast11 Unmanaged.native_batch_norm_out_ttttttttbdd
+
 batch_norm_stats_td
   :: ForeignPtr Tensor
   -> CDouble
@@ -5384,17 +5663,6 @@ ones_out_tl
   -> IO (ForeignPtr Tensor)
 ones_out_tl = cast2 Unmanaged.ones_out_tl
 
-ones_like_tM
-  :: ForeignPtr Tensor
-  -> MemoryFormat
-  -> IO (ForeignPtr Tensor)
-ones_like_tM = cast2 Unmanaged.ones_like_tM
-
-ones_like_t
-  :: ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-ones_like_t = cast1 Unmanaged.ones_like_t
-
 ones_like_toM
   :: ForeignPtr Tensor
   -> ForeignPtr TensorOptions
@@ -5408,6 +5676,11 @@ ones_like_to
   -> IO (ForeignPtr Tensor)
 ones_like_to = cast2 Unmanaged.ones_like_to
 
+ones_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ones_like_t = cast1 Unmanaged.ones_like_t
+
 pairwise_distance_ttddb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -5459,6 +5732,14 @@ cdist_tt
   -> IO (ForeignPtr Tensor)
 cdist_tt = cast2 Unmanaged.cdist_tt
 
+_cdist_forward_ttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_cdist_forward_ttdl = cast4 Unmanaged._cdist_forward_ttdl
+
 _cdist_backward_tttdt
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -5622,17 +5903,6 @@ rand_out_tlp
   -> IO (ForeignPtr Tensor)
 rand_out_tlp = cast3 Unmanaged.rand_out_tlp
 
-rand_like_tM
-  :: ForeignPtr Tensor
-  -> MemoryFormat
-  -> IO (ForeignPtr Tensor)
-rand_like_tM = cast2 Unmanaged.rand_like_tM
-
-rand_like_t
-  :: ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-rand_like_t = cast1 Unmanaged.rand_like_t
-
 rand_like_toM
   :: ForeignPtr Tensor
   -> ForeignPtr TensorOptions
@@ -5646,6 +5916,11 @@ rand_like_to
   -> IO (ForeignPtr Tensor)
 rand_like_to = cast2 Unmanaged.rand_like_to
 
+rand_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rand_like_t = cast1 Unmanaged.rand_like_t
+
 randint_llo
   :: Int64
   -> ForeignPtr IntArray
@@ -5738,34 +6013,6 @@ randint_out_tlllp
   -> IO (ForeignPtr Tensor)
 randint_out_tlllp = cast5 Unmanaged.randint_out_tlllp
 
-randint_like_tlM
-  :: ForeignPtr Tensor
-  -> Int64
-  -> MemoryFormat
-  -> IO (ForeignPtr Tensor)
-randint_like_tlM = cast3 Unmanaged.randint_like_tlM
-
-randint_like_tl
-  :: ForeignPtr Tensor
-  -> Int64
-  -> IO (ForeignPtr Tensor)
-randint_like_tl = cast2 Unmanaged.randint_like_tl
-
-randint_like_tllM
-  :: ForeignPtr Tensor
-  -> Int64
-  -> Int64
-  -> MemoryFormat
-  -> IO (ForeignPtr Tensor)
-randint_like_tllM = cast4 Unmanaged.randint_like_tllM
-
-randint_like_tll
-  :: ForeignPtr Tensor
-  -> Int64
-  -> Int64
-  -> IO (ForeignPtr Tensor)
-randint_like_tll = cast3 Unmanaged.randint_like_tll
-
 randint_like_tloM
   :: ForeignPtr Tensor
   -> Int64
@@ -5781,6 +6028,12 @@ randint_like_tlo
   -> IO (ForeignPtr Tensor)
 randint_like_tlo = cast3 Unmanaged.randint_like_tlo
 
+randint_like_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+randint_like_tl = cast2 Unmanaged.randint_like_tl
+
 randint_like_tlloM
   :: ForeignPtr Tensor
   -> Int64
@@ -5798,6 +6051,13 @@ randint_like_tllo
   -> IO (ForeignPtr Tensor)
 randint_like_tllo = cast4 Unmanaged.randint_like_tllo
 
+randint_like_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+randint_like_tll = cast3 Unmanaged.randint_like_tll
+
 randn_lo
   :: ForeignPtr IntArray
   -> ForeignPtr TensorOptions
@@ -5863,17 +6123,6 @@ randn_out_tlp
   -> IO (ForeignPtr Tensor)
 randn_out_tlp = cast3 Unmanaged.randn_out_tlp
 
-randn_like_tM
-  :: ForeignPtr Tensor
-  -> MemoryFormat
-  -> IO (ForeignPtr Tensor)
-randn_like_tM = cast2 Unmanaged.randn_like_tM
-
-randn_like_t
-  :: ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-randn_like_t = cast1 Unmanaged.randn_like_t
-
 randn_like_toM
   :: ForeignPtr Tensor
   -> ForeignPtr TensorOptions
@@ -5887,6 +6136,11 @@ randn_like_to
   -> IO (ForeignPtr Tensor)
 randn_like_to = cast2 Unmanaged.randn_like_to
 
+randn_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+randn_like_t = cast1 Unmanaged.randn_like_t
+
 randperm_lo
   :: Int64
   -> ForeignPtr TensorOptions
@@ -6697,6 +6951,16 @@ sqrt_out_tt
   -> IO (ForeignPtr Tensor)
 sqrt_out_tt = cast2 Unmanaged.sqrt_out_tt
 
+square_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+square_t = cast1 Unmanaged.square_t
+
+square__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+square__t = cast1 Unmanaged.square__t
+
 std_tb
   :: ForeignPtr Tensor
   -> CBool
@@ -7213,7 +7477,26 @@ triplet_margin_loss_ttt
   -> IO (ForeignPtr Tensor)
 triplet_margin_loss_ttt = cast3 Unmanaged.triplet_margin_loss_ttt
 
-trunc_t
+true_divide_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+true_divide_tt = cast2 Unmanaged.true_divide_tt
+
+true_divide_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+true_divide_out_ttt = cast3 Unmanaged.true_divide_out_ttt
+
+true_divide_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+true_divide_ts = cast2 Unmanaged.true_divide_ts
+
+trunc_t
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
 trunc_t = cast1 Unmanaged.trunc_t
@@ -7633,17 +7916,6 @@ zeros_out_tl
   -> IO (ForeignPtr Tensor)
 zeros_out_tl = cast2 Unmanaged.zeros_out_tl
 
-zeros_like_tM
-  :: ForeignPtr Tensor
-  -> MemoryFormat
-  -> IO (ForeignPtr Tensor)
-zeros_like_tM = cast2 Unmanaged.zeros_like_tM
-
-zeros_like_t
-  :: ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-zeros_like_t = cast1 Unmanaged.zeros_like_t
-
 zeros_like_toM
   :: ForeignPtr Tensor
   -> ForeignPtr TensorOptions
@@ -7657,6 +7929,11 @@ zeros_like_to
   -> IO (ForeignPtr Tensor)
 zeros_like_to = cast2 Unmanaged.zeros_like_to
 
+zeros_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+zeros_like_t = cast1 Unmanaged.zeros_like_t
+
 _standard_gamma_grad_tt
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -9089,6 +9366,32 @@ scatter_add_tntt
   -> IO (ForeignPtr Tensor)
 scatter_add_tntt = cast4 Unmanaged.scatter_add_tntt
 
+bitwise_and_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_and_out_ttt = cast3 Unmanaged.bitwise_and_out_ttt
+
+bitwise_and_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_and_out_tts = cast3 Unmanaged.bitwise_and_out_tts
+
+bitwise_and_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_and_ts = cast2 Unmanaged.bitwise_and_ts
+
+bitwise_and_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_and_tt = cast2 Unmanaged.bitwise_and_tt
+
 __and___ts
   :: ForeignPtr Tensor
   -> ForeignPtr Scalar
@@ -9101,6 +9404,32 @@ __and___tt
   -> IO (ForeignPtr Tensor)
 __and___tt = cast2 Unmanaged.__and___tt
 
+bitwise_or_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_or_out_ttt = cast3 Unmanaged.bitwise_or_out_ttt
+
+bitwise_or_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_or_out_tts = cast3 Unmanaged.bitwise_or_out_tts
+
+bitwise_or_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_or_ts = cast2 Unmanaged.bitwise_or_ts
+
+bitwise_or_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_or_tt = cast2 Unmanaged.bitwise_or_tt
+
 __or___ts
   :: ForeignPtr Tensor
   -> ForeignPtr Scalar
@@ -11041,6 +11370,23 @@ _std_t
   -> IO (ForeignPtr Tensor)
 _std_t = cast1 Unmanaged._std_t
 
+_amp_non_finite_check_and_unscale__ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+_amp_non_finite_check_and_unscale__ttt = cast3 Unmanaged._amp_non_finite_check_and_unscale__ttt
+
+_amp_update_scale_tttddl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_amp_update_scale_tttddl = cast6 Unmanaged._amp_update_scale_tttddl
+
 _cat_ll
   :: ForeignPtr TensorList
   -> Int64
@@ -11167,102 +11513,6 @@ _min_out_tttl
   -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
 _min_out_tttl = cast4 Unmanaged._min_out_tttl
 
-binary_cross_entropy_out_ttttl
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> Int64
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_out_ttttl = cast5 Unmanaged.binary_cross_entropy_out_ttttl
-
-binary_cross_entropy_out_tttt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_out_tttt = cast4 Unmanaged.binary_cross_entropy_out_tttt
-
-binary_cross_entropy_out_ttt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_out_ttt = cast3 Unmanaged.binary_cross_entropy_out_ttt
-
-binary_cross_entropy_tttl
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> Int64
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_tttl = cast4 Unmanaged.binary_cross_entropy_tttl
-
-binary_cross_entropy_ttt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_ttt = cast3 Unmanaged.binary_cross_entropy_ttt
-
-binary_cross_entropy_tt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_tt = cast2 Unmanaged.binary_cross_entropy_tt
-
-binary_cross_entropy_backward_out_tttttl
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> Int64
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_backward_out_tttttl = cast6 Unmanaged.binary_cross_entropy_backward_out_tttttl
-
-binary_cross_entropy_backward_out_ttttt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_backward_out_ttttt = cast5 Unmanaged.binary_cross_entropy_backward_out_ttttt
-
-binary_cross_entropy_backward_out_tttt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_backward_out_tttt = cast4 Unmanaged.binary_cross_entropy_backward_out_tttt
-
-binary_cross_entropy_backward_ttttl
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> Int64
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_backward_ttttl = cast5 Unmanaged.binary_cross_entropy_backward_ttttl
-
-binary_cross_entropy_backward_tttt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_backward_tttt = cast4 Unmanaged.binary_cross_entropy_backward_tttt
-
-binary_cross_entropy_backward_ttt
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-binary_cross_entropy_backward_ttt = cast3 Unmanaged.binary_cross_entropy_backward_ttt
-
 mse_loss_out_tttl
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -12008,6 +12258,28 @@ glu_backward_ttl
   -> IO (ForeignPtr Tensor)
 glu_backward_ttl = cast3 Unmanaged.glu_backward_ttl
 
+hardsigmoid_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardsigmoid_out_tt = cast2 Unmanaged.hardsigmoid_out_tt
+
+hardsigmoid_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardsigmoid_t = cast1 Unmanaged.hardsigmoid_t
+
+hardsigmoid__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardsigmoid__t = cast1 Unmanaged.hardsigmoid__t
+
+hardsigmoid_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardsigmoid_backward_tt = cast2 Unmanaged.hardsigmoid_backward_tt
+
 hardtanh_out_ttss
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -12106,20 +12378,13 @@ leaky_relu_t
   -> IO (ForeignPtr Tensor)
 leaky_relu_t = cast1 Unmanaged.leaky_relu_t
 
-leaky_relu_backward_out_ttts
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Scalar
-  -> IO (ForeignPtr Tensor)
-leaky_relu_backward_out_ttts = cast4 Unmanaged.leaky_relu_backward_out_ttts
-
-leaky_relu_backward_tts
+leaky_relu_backward_ttsb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
   -> ForeignPtr Scalar
+  -> CBool
   -> IO (ForeignPtr Tensor)
-leaky_relu_backward_tts = cast3 Unmanaged.leaky_relu_backward_tts
+leaky_relu_backward_ttsb = cast4 Unmanaged.leaky_relu_backward_ttsb
 
 leaky_relu__ts
   :: ForeignPtr Tensor
@@ -12255,26 +12520,16 @@ rrelu_with_noise_tt
   -> IO (ForeignPtr Tensor)
 rrelu_with_noise_tt = cast2 Unmanaged.rrelu_with_noise_tt
 
-rrelu_with_noise_backward_out_ttttssb
+rrelu_with_noise_backward_tttssbb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
   -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
   -> ForeignPtr Scalar
   -> ForeignPtr Scalar
   -> CBool
-  -> IO (ForeignPtr Tensor)
-rrelu_with_noise_backward_out_ttttssb = cast7 Unmanaged.rrelu_with_noise_backward_out_ttttssb
-
-rrelu_with_noise_backward_tttssb
-  :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Tensor
-  -> ForeignPtr Scalar
-  -> ForeignPtr Scalar
   -> CBool
   -> IO (ForeignPtr Tensor)
-rrelu_with_noise_backward_tttssb = cast6 Unmanaged.rrelu_with_noise_backward_tttssb
+rrelu_with_noise_backward_tttssbb = cast7 Unmanaged.rrelu_with_noise_backward_tttssbb
 
 rrelu_with_noise__ttssbp
   :: ForeignPtr Tensor
@@ -13310,16 +13565,14 @@ replication_pad3d_backward_ttl
   -> IO (ForeignPtr Tensor)
 replication_pad3d_backward_ttl = cast3 Unmanaged.replication_pad3d_backward_ttl
 
-_test_optional_float_td
+upsample_linear1d_out_ttlbd
   :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
   -> CDouble
   -> IO (ForeignPtr Tensor)
-_test_optional_float_td = cast2 Unmanaged._test_optional_float_td
-
-_test_optional_float_t
-  :: ForeignPtr Tensor
-  -> IO (ForeignPtr Tensor)
-_test_optional_float_t = cast1 Unmanaged._test_optional_float_t
+upsample_linear1d_out_ttlbd = cast5 Unmanaged.upsample_linear1d_out_ttlbd
 
 upsample_linear1d_out_ttlb
   :: ForeignPtr Tensor
@@ -13329,6 +13582,14 @@ upsample_linear1d_out_ttlb
   -> IO (ForeignPtr Tensor)
 upsample_linear1d_out_ttlb = cast4 Unmanaged.upsample_linear1d_out_ttlb
 
+upsample_linear1d_tlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_linear1d_tlbd = cast4 Unmanaged.upsample_linear1d_tlbd
+
 upsample_linear1d_tlb
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -13336,6 +13597,16 @@ upsample_linear1d_tlb
   -> IO (ForeignPtr Tensor)
 upsample_linear1d_tlb = cast3 Unmanaged.upsample_linear1d_tlb
 
+upsample_linear1d_backward_out_ttllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_linear1d_backward_out_ttllbd = cast6 Unmanaged.upsample_linear1d_backward_out_ttllbd
+
 upsample_linear1d_backward_out_ttllb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13345,6 +13616,15 @@ upsample_linear1d_backward_out_ttllb
   -> IO (ForeignPtr Tensor)
 upsample_linear1d_backward_out_ttllb = cast5 Unmanaged.upsample_linear1d_backward_out_ttllb
 
+upsample_linear1d_backward_tllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_linear1d_backward_tllbd = cast5 Unmanaged.upsample_linear1d_backward_tllbd
+
 upsample_linear1d_backward_tllb
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -13353,62 +13633,214 @@ upsample_linear1d_backward_tllb
   -> IO (ForeignPtr Tensor)
 upsample_linear1d_backward_tllb = cast4 Unmanaged.upsample_linear1d_backward_tllb
 
-upsample_bilinear2d_out_ttlb
+upsample_bilinear2d_out_ttlbdd
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
   -> ForeignPtr IntArray
   -> CBool
+  -> CDouble
+  -> CDouble
   -> IO (ForeignPtr Tensor)
-upsample_bilinear2d_out_ttlb = cast4 Unmanaged.upsample_bilinear2d_out_ttlb
+upsample_bilinear2d_out_ttlbdd = cast6 Unmanaged.upsample_bilinear2d_out_ttlbdd
 
-upsample_bilinear2d_tlb
+upsample_bilinear2d_out_ttlbd
   :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
   -> ForeignPtr IntArray
   -> CBool
+  -> CDouble
   -> IO (ForeignPtr Tensor)
-upsample_bilinear2d_tlb = cast3 Unmanaged.upsample_bilinear2d_tlb
+upsample_bilinear2d_out_ttlbd = cast5 Unmanaged.upsample_bilinear2d_out_ttlbd
 
-upsample_bilinear2d_backward_out_ttllb
+upsample_bilinear2d_out_ttlb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
   -> ForeignPtr IntArray
-  -> ForeignPtr IntArray
   -> CBool
   -> IO (ForeignPtr Tensor)
-upsample_bilinear2d_backward_out_ttllb = cast5 Unmanaged.upsample_bilinear2d_backward_out_ttllb
+upsample_bilinear2d_out_ttlb = cast4 Unmanaged.upsample_bilinear2d_out_ttlb
 
-upsample_bilinear2d_backward_tllb
+upsample_bilinear2d_tlbdd
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
-  -> ForeignPtr IntArray
   -> CBool
+  -> CDouble
+  -> CDouble
   -> IO (ForeignPtr Tensor)
-upsample_bilinear2d_backward_tllb = cast4 Unmanaged.upsample_bilinear2d_backward_tllb
+upsample_bilinear2d_tlbdd = cast5 Unmanaged.upsample_bilinear2d_tlbdd
 
-upsample_bicubic2d_out_ttlb
+upsample_bilinear2d_tlbd
   :: ForeignPtr Tensor
-  -> ForeignPtr Tensor
   -> ForeignPtr IntArray
   -> CBool
+  -> CDouble
   -> IO (ForeignPtr Tensor)
-upsample_bicubic2d_out_ttlb = cast4 Unmanaged.upsample_bicubic2d_out_ttlb
+upsample_bilinear2d_tlbd = cast4 Unmanaged.upsample_bilinear2d_tlbd
 
-upsample_bicubic2d_tlb
+upsample_bilinear2d_tlb
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
   -> CBool
   -> IO (ForeignPtr Tensor)
-upsample_bicubic2d_tlb = cast3 Unmanaged.upsample_bicubic2d_tlb
+upsample_bilinear2d_tlb = cast3 Unmanaged.upsample_bilinear2d_tlb
 
-upsample_bicubic2d_backward_out_ttllb
+upsample_bilinear2d_backward_out_ttllbdd
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
   -> ForeignPtr IntArray
   -> ForeignPtr IntArray
   -> CBool
-  -> IO (ForeignPtr Tensor)
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_backward_out_ttllbdd = cast7 Unmanaged.upsample_bilinear2d_backward_out_ttllbdd
+
+upsample_bilinear2d_backward_out_ttllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_backward_out_ttllbd = cast6 Unmanaged.upsample_bilinear2d_backward_out_ttllbd
+
+upsample_bilinear2d_backward_out_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_backward_out_ttllb = cast5 Unmanaged.upsample_bilinear2d_backward_out_ttllb
+
+upsample_bilinear2d_backward_tllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_backward_tllbdd = cast6 Unmanaged.upsample_bilinear2d_backward_tllbdd
+
+upsample_bilinear2d_backward_tllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_backward_tllbd = cast5 Unmanaged.upsample_bilinear2d_backward_tllbd
+
+upsample_bilinear2d_backward_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_backward_tllb = cast4 Unmanaged.upsample_bilinear2d_backward_tllb
+
+upsample_bicubic2d_out_ttlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_out_ttlbdd = cast6 Unmanaged.upsample_bicubic2d_out_ttlbdd
+
+upsample_bicubic2d_out_ttlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_out_ttlbd = cast5 Unmanaged.upsample_bicubic2d_out_ttlbd
+
+upsample_bicubic2d_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_out_ttlb = cast4 Unmanaged.upsample_bicubic2d_out_ttlb
+
+upsample_bicubic2d_tlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_tlbdd = cast5 Unmanaged.upsample_bicubic2d_tlbdd
+
+upsample_bicubic2d_tlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_tlbd = cast4 Unmanaged.upsample_bicubic2d_tlbd
+
+upsample_bicubic2d_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_tlb = cast3 Unmanaged.upsample_bicubic2d_tlb
+
+upsample_bicubic2d_backward_out_ttllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_backward_out_ttllbdd = cast7 Unmanaged.upsample_bicubic2d_backward_out_ttllbdd
+
+upsample_bicubic2d_backward_out_ttllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_backward_out_ttllbd = cast6 Unmanaged.upsample_bicubic2d_backward_out_ttllbd
+
+upsample_bicubic2d_backward_out_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
 upsample_bicubic2d_backward_out_ttllb = cast5 Unmanaged.upsample_bicubic2d_backward_out_ttllb
 
+upsample_bicubic2d_backward_tllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_backward_tllbdd = cast6 Unmanaged.upsample_bicubic2d_backward_tllbdd
+
+upsample_bicubic2d_backward_tllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_backward_tllbd = cast5 Unmanaged.upsample_bicubic2d_backward_tllbd
+
 upsample_bicubic2d_backward_tllb
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -13417,6 +13849,36 @@ upsample_bicubic2d_backward_tllb
   -> IO (ForeignPtr Tensor)
 upsample_bicubic2d_backward_tllb = cast4 Unmanaged.upsample_bicubic2d_backward_tllb
 
+upsample_trilinear3d_out_ttlbddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_out_ttlbddd = cast7 Unmanaged.upsample_trilinear3d_out_ttlbddd
+
+upsample_trilinear3d_out_ttlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_out_ttlbdd = cast6 Unmanaged.upsample_trilinear3d_out_ttlbdd
+
+upsample_trilinear3d_out_ttlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_out_ttlbd = cast5 Unmanaged.upsample_trilinear3d_out_ttlbd
+
 upsample_trilinear3d_out_ttlb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13425,6 +13887,33 @@ upsample_trilinear3d_out_ttlb
   -> IO (ForeignPtr Tensor)
 upsample_trilinear3d_out_ttlb = cast4 Unmanaged.upsample_trilinear3d_out_ttlb
 
+upsample_trilinear3d_tlbddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_tlbddd = cast6 Unmanaged.upsample_trilinear3d_tlbddd
+
+upsample_trilinear3d_tlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_tlbdd = cast5 Unmanaged.upsample_trilinear3d_tlbdd
+
+upsample_trilinear3d_tlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_tlbd = cast4 Unmanaged.upsample_trilinear3d_tlbd
+
 upsample_trilinear3d_tlb
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -13432,6 +13921,39 @@ upsample_trilinear3d_tlb
   -> IO (ForeignPtr Tensor)
 upsample_trilinear3d_tlb = cast3 Unmanaged.upsample_trilinear3d_tlb
 
+upsample_trilinear3d_backward_out_ttllbddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_backward_out_ttllbddd = cast8 Unmanaged.upsample_trilinear3d_backward_out_ttllbddd
+
+upsample_trilinear3d_backward_out_ttllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_backward_out_ttllbdd = cast7 Unmanaged.upsample_trilinear3d_backward_out_ttllbdd
+
+upsample_trilinear3d_backward_out_ttllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_backward_out_ttllbd = cast6 Unmanaged.upsample_trilinear3d_backward_out_ttllbd
+
 upsample_trilinear3d_backward_out_ttllb
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13441,6 +13963,36 @@ upsample_trilinear3d_backward_out_ttllb
   -> IO (ForeignPtr Tensor)
 upsample_trilinear3d_backward_out_ttllb = cast5 Unmanaged.upsample_trilinear3d_backward_out_ttllb
 
+upsample_trilinear3d_backward_tllbddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_backward_tllbddd = cast7 Unmanaged.upsample_trilinear3d_backward_tllbddd
+
+upsample_trilinear3d_backward_tllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_backward_tllbdd = cast6 Unmanaged.upsample_trilinear3d_backward_tllbdd
+
+upsample_trilinear3d_backward_tllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_backward_tllbd = cast5 Unmanaged.upsample_trilinear3d_backward_tllbd
+
 upsample_trilinear3d_backward_tllb
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -13449,6 +14001,14 @@ upsample_trilinear3d_backward_tllb
   -> IO (ForeignPtr Tensor)
 upsample_trilinear3d_backward_tllb = cast4 Unmanaged.upsample_trilinear3d_backward_tllb
 
+upsample_nearest1d_out_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_out_ttld = cast4 Unmanaged.upsample_nearest1d_out_ttld
+
 upsample_nearest1d_out_ttl
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13456,12 +14016,28 @@ upsample_nearest1d_out_ttl
   -> IO (ForeignPtr Tensor)
 upsample_nearest1d_out_ttl = cast3 Unmanaged.upsample_nearest1d_out_ttl
 
+upsample_nearest1d_tld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_tld = cast3 Unmanaged.upsample_nearest1d_tld
+
 upsample_nearest1d_tl
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
   -> IO (ForeignPtr Tensor)
 upsample_nearest1d_tl = cast2 Unmanaged.upsample_nearest1d_tl
 
+upsample_nearest1d_backward_out_ttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_backward_out_ttlld = cast5 Unmanaged.upsample_nearest1d_backward_out_ttlld
+
 upsample_nearest1d_backward_out_ttll
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13470,6 +14046,14 @@ upsample_nearest1d_backward_out_ttll
   -> IO (ForeignPtr Tensor)
 upsample_nearest1d_backward_out_ttll = cast4 Unmanaged.upsample_nearest1d_backward_out_ttll
 
+upsample_nearest1d_backward_tlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_backward_tlld = cast4 Unmanaged.upsample_nearest1d_backward_tlld
+
 upsample_nearest1d_backward_tll
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -13477,6 +14061,23 @@ upsample_nearest1d_backward_tll
   -> IO (ForeignPtr Tensor)
 upsample_nearest1d_backward_tll = cast3 Unmanaged.upsample_nearest1d_backward_tll
 
+upsample_nearest2d_out_ttldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_out_ttldd = cast5 Unmanaged.upsample_nearest2d_out_ttldd
+
+upsample_nearest2d_out_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_out_ttld = cast4 Unmanaged.upsample_nearest2d_out_ttld
+
 upsample_nearest2d_out_ttl
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13484,12 +14085,46 @@ upsample_nearest2d_out_ttl
   -> IO (ForeignPtr Tensor)
 upsample_nearest2d_out_ttl = cast3 Unmanaged.upsample_nearest2d_out_ttl
 
+upsample_nearest2d_tldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_tldd = cast4 Unmanaged.upsample_nearest2d_tldd
+
+upsample_nearest2d_tld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_tld = cast3 Unmanaged.upsample_nearest2d_tld
+
 upsample_nearest2d_tl
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
   -> IO (ForeignPtr Tensor)
 upsample_nearest2d_tl = cast2 Unmanaged.upsample_nearest2d_tl
 
+upsample_nearest2d_backward_out_ttlldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_backward_out_ttlldd = cast6 Unmanaged.upsample_nearest2d_backward_out_ttlldd
+
+upsample_nearest2d_backward_out_ttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_backward_out_ttlld = cast5 Unmanaged.upsample_nearest2d_backward_out_ttlld
+
 upsample_nearest2d_backward_out_ttll
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13498,6 +14133,23 @@ upsample_nearest2d_backward_out_ttll
   -> IO (ForeignPtr Tensor)
 upsample_nearest2d_backward_out_ttll = cast4 Unmanaged.upsample_nearest2d_backward_out_ttll
 
+upsample_nearest2d_backward_tlldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_backward_tlldd = cast5 Unmanaged.upsample_nearest2d_backward_tlldd
+
+upsample_nearest2d_backward_tlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_backward_tlld = cast4 Unmanaged.upsample_nearest2d_backward_tlld
+
 upsample_nearest2d_backward_tll
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -13505,6 +14157,33 @@ upsample_nearest2d_backward_tll
   -> IO (ForeignPtr Tensor)
 upsample_nearest2d_backward_tll = cast3 Unmanaged.upsample_nearest2d_backward_tll
 
+upsample_nearest3d_out_ttlddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_out_ttlddd = cast6 Unmanaged.upsample_nearest3d_out_ttlddd
+
+upsample_nearest3d_out_ttldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_out_ttldd = cast5 Unmanaged.upsample_nearest3d_out_ttldd
+
+upsample_nearest3d_out_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_out_ttld = cast4 Unmanaged.upsample_nearest3d_out_ttld
+
 upsample_nearest3d_out_ttl
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13512,12 +14191,66 @@ upsample_nearest3d_out_ttl
   -> IO (ForeignPtr Tensor)
 upsample_nearest3d_out_ttl = cast3 Unmanaged.upsample_nearest3d_out_ttl
 
+upsample_nearest3d_tlddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_tlddd = cast5 Unmanaged.upsample_nearest3d_tlddd
+
+upsample_nearest3d_tldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_tldd = cast4 Unmanaged.upsample_nearest3d_tldd
+
+upsample_nearest3d_tld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_tld = cast3 Unmanaged.upsample_nearest3d_tld
+
 upsample_nearest3d_tl
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
   -> IO (ForeignPtr Tensor)
 upsample_nearest3d_tl = cast2 Unmanaged.upsample_nearest3d_tl
 
+upsample_nearest3d_backward_out_ttllddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_backward_out_ttllddd = cast7 Unmanaged.upsample_nearest3d_backward_out_ttllddd
+
+upsample_nearest3d_backward_out_ttlldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_backward_out_ttlldd = cast6 Unmanaged.upsample_nearest3d_backward_out_ttlldd
+
+upsample_nearest3d_backward_out_ttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_backward_out_ttlld = cast5 Unmanaged.upsample_nearest3d_backward_out_ttlld
+
 upsample_nearest3d_backward_out_ttll
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -13526,6 +14259,33 @@ upsample_nearest3d_backward_out_ttll
   -> IO (ForeignPtr Tensor)
 upsample_nearest3d_backward_out_ttll = cast4 Unmanaged.upsample_nearest3d_backward_out_ttll
 
+upsample_nearest3d_backward_tllddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_backward_tllddd = cast6 Unmanaged.upsample_nearest3d_backward_tllddd
+
+upsample_nearest3d_backward_tlldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_backward_tlldd = cast5 Unmanaged.upsample_nearest3d_backward_tlldd
+
+upsample_nearest3d_backward_tlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_backward_tlld = cast4 Unmanaged.upsample_nearest3d_backward_tlld
+
 upsample_nearest3d_backward_tll
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -14451,3 +15211,8 @@ isfinite_t
   -> IO (ForeignPtr Tensor)
 isfinite_t = cast1 Unmanaged.isfinite_t
 
+isinf_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isinf_t = cast1 Unmanaged.isinf_t
+
diff --git a/libtorch-ffi/src/Torch/Internal/Managed/TensorFactories.hs b/libtorch-ffi/src/Torch/Internal/Managed/TensorFactories.hs
index d2685542b..018aa43fd 100644
--- a/libtorch-ffi/src/Torch/Internal/Managed/TensorFactories.hs
+++ b/libtorch-ffi/src/Torch/Internal/Managed/TensorFactories.hs
@@ -241,6 +241,11 @@ empty_like_to
   -> IO (ForeignPtr Tensor)
 empty_like_to = cast2 Unmanaged.empty_like_to
 
+empty_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+empty_like_t = cast1 Unmanaged.empty_like_t
+
 empty_strided_llo
   :: ForeignPtr IntArray
   -> ForeignPtr IntArray
@@ -321,6 +326,12 @@ full_like_tso
   -> IO (ForeignPtr Tensor)
 full_like_tso = cast3 Unmanaged.full_like_tso
 
+full_like_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+full_like_ts = cast2 Unmanaged.full_like_ts
+
 from_file_sblo
   :: ForeignPtr StdString
   -> CBool
@@ -515,6 +526,11 @@ ones_like_to
   -> IO (ForeignPtr Tensor)
 ones_like_to = cast2 Unmanaged.ones_like_to
 
+ones_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ones_like_t = cast1 Unmanaged.ones_like_t
+
 scalar_tensor_so
   :: ForeignPtr Scalar
   -> ForeignPtr TensorOptions
@@ -591,6 +607,11 @@ rand_like_to
   -> IO (ForeignPtr Tensor)
 rand_like_to = cast2 Unmanaged.rand_like_to
 
+rand_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rand_like_t = cast1 Unmanaged.rand_like_t
+
 randint_llo
   :: Int64
   -> ForeignPtr IntArray
@@ -666,6 +687,12 @@ randint_like_tlo
   -> IO (ForeignPtr Tensor)
 randint_like_tlo = cast3 Unmanaged.randint_like_tlo
 
+randint_like_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+randint_like_tl = cast2 Unmanaged.randint_like_tl
+
 randint_like_tlloM
   :: ForeignPtr Tensor
   -> Int64
@@ -683,6 +710,13 @@ randint_like_tllo
   -> IO (ForeignPtr Tensor)
 randint_like_tllo = cast4 Unmanaged.randint_like_tllo
 
+randint_like_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+randint_like_tll = cast3 Unmanaged.randint_like_tll
+
 randn_lo
   :: ForeignPtr IntArray
   -> ForeignPtr TensorOptions
@@ -748,6 +782,11 @@ randn_like_to
   -> IO (ForeignPtr Tensor)
 randn_like_to = cast2 Unmanaged.randn_like_to
 
+randn_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+randn_like_t = cast1 Unmanaged.randn_like_t
+
 randperm_lo
   :: Int64
   -> ForeignPtr TensorOptions
@@ -837,6 +876,11 @@ zeros_like_to
   -> IO (ForeignPtr Tensor)
 zeros_like_to = cast2 Unmanaged.zeros_like_to
 
+zeros_like_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+zeros_like_t = cast1 Unmanaged.zeros_like_t
+
 sparse_coo_tensor_lo
   :: ForeignPtr IntArray
   -> ForeignPtr TensorOptions
diff --git a/libtorch-ffi/src/Torch/Internal/Managed/Type/IValue.hs b/libtorch-ffi/src/Torch/Internal/Managed/Type/IValue.hs
index 71d30578a..58cca2020 100644
--- a/libtorch-ffi/src/Torch/Internal/Managed/Type/IValue.hs
+++ b/libtorch-ffi/src/Torch/Internal/Managed/Type/IValue.hs
@@ -157,10 +157,10 @@ iValue_isTensorList
   -> IO (CBool)
 iValue_isTensorList = cast1 Unmanaged.iValue_isTensorList
 
-iValue_isGenericList
+iValue_isList
   :: ForeignPtr IValue
   -> IO (CBool)
-iValue_isGenericList = cast1 Unmanaged.iValue_isGenericList
+iValue_isList = cast1 Unmanaged.iValue_isList
 
 iValue_isGenericDict
   :: ForeignPtr IValue
diff --git a/libtorch-ffi/src/Torch/Internal/Managed/Type/Tensor.hs b/libtorch-ffi/src/Torch/Internal/Managed/Type/Tensor.hs
index 7eccf04e1..f0ba714a4 100644
--- a/libtorch-ffi/src/Torch/Internal/Managed/Type/Tensor.hs
+++ b/libtorch-ffi/src/Torch/Internal/Managed/Type/Tensor.hs
@@ -70,7 +70,7 @@ tensor_reset = cast1 Unmanaged.tensor_reset
 tensor__assign__t
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
-  -> IO (())
+  -> IO (ForeignPtr Tensor)
 tensor__assign__t = cast2 Unmanaged.tensor__assign__t
 
 tensor_is_same_t
@@ -114,11 +114,21 @@ tensor_is_contiguous
   -> IO (CBool)
 tensor_is_contiguous = cast1 Unmanaged.tensor_is_contiguous
 
+tensor_is_non_overlapping_and_dense
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_non_overlapping_and_dense = cast1 Unmanaged.tensor_is_non_overlapping_and_dense
+
 tensor_nbytes
   :: ForeignPtr Tensor
   -> IO (CSize)
 tensor_nbytes = cast1 Unmanaged.tensor_nbytes
 
+tensor_numel
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_numel = cast1 Unmanaged.tensor_numel
+
 tensor_itemsize
   :: ForeignPtr Tensor
   -> IO (CSize)
@@ -126,7 +136,7 @@ tensor_itemsize = cast1 Unmanaged.tensor_itemsize
 
 tensor_element_size
   :: ForeignPtr Tensor
-  -> IO (CSize)
+  -> IO (Int64)
 tensor_element_size = cast1 Unmanaged.tensor_element_size
 
 tensor_scalar_type
@@ -368,12 +378,30 @@ tensor__version
   -> IO (Int64)
 tensor__version = cast1 Unmanaged.tensor__version
 
+tensor_requires_grad__b
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_requires_grad__b = cast2 Unmanaged.tensor_requires_grad__b
+
+tensor_retain_grad
+  :: ForeignPtr Tensor
+  -> IO (())
+tensor_retain_grad = cast1 Unmanaged.tensor_retain_grad
+
 tensor_align_to_N
   :: ForeignPtr Tensor
   -> ForeignPtr DimnameList
   -> IO (ForeignPtr Tensor)
 tensor_align_to_N = cast2 Unmanaged.tensor_align_to_N
 
+tensor_align_to_Nl
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_align_to_Nl = cast3 Unmanaged.tensor_align_to_Nl
+
 tensor_align_as_t
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -412,6 +440,16 @@ tensor_abs_
   -> IO (ForeignPtr Tensor)
 tensor_abs_ = cast1 Unmanaged.tensor_abs_
 
+tensor_angle
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_angle = cast1 Unmanaged.tensor_angle
+
+tensor_conj
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_conj = cast1 Unmanaged.tensor_conj
+
 tensor_acos
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
@@ -627,6 +665,30 @@ tensor_logical_xor__t
   -> IO (ForeignPtr Tensor)
 tensor_logical_xor__t = cast2 Unmanaged.tensor_logical_xor__t
 
+tensor_logical_and_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logical_and_t = cast2 Unmanaged.tensor_logical_and_t
+
+tensor_logical_and__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logical_and__t = cast2 Unmanaged.tensor_logical_and__t
+
+tensor_logical_or_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logical_or_t = cast2 Unmanaged.tensor_logical_or_t
+
+tensor_logical_or__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logical_or__t = cast2 Unmanaged.tensor_logical_or__t
+
 tensor_bmm_t
   :: ForeignPtr Tensor
   -> ForeignPtr Tensor
@@ -706,6 +768,30 @@ tensor_cosh_
   -> IO (ForeignPtr Tensor)
 tensor_cosh_ = cast1 Unmanaged.tensor_cosh_
 
+tensor_cummax_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_cummax_l = cast2 Unmanaged.tensor_cummax_l
+
+tensor_cummax_n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_cummax_n = cast2 Unmanaged.tensor_cummax_n
+
+tensor_cummin_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_cummin_l = cast2 Unmanaged.tensor_cummin_l
+
+tensor_cummin_n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_cummin_n = cast2 Unmanaged.tensor_cummin_n
+
 tensor_det
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
@@ -733,6 +819,15 @@ tensor_diagonal_lll
   -> IO (ForeignPtr Tensor)
 tensor_diagonal_lll = cast4 Unmanaged.tensor_diagonal_lll
 
+tensor_diagonal_nnnl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_diagonal_nnnl = cast5 Unmanaged.tensor_diagonal_nnnl
+
 tensor_fill_diagonal__sb
   :: ForeignPtr Tensor
   -> ForeignPtr Scalar
@@ -791,6 +886,13 @@ tensor_resize__l
   -> IO (ForeignPtr Tensor)
 tensor_resize__l = cast2 Unmanaged.tensor_resize__l
 
+tensor_new_zeros_lo
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+tensor_new_zeros_lo = cast3 Unmanaged.tensor_new_zeros_lo
+
 tensor_erf
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
@@ -896,6 +998,30 @@ tensor_floor_
   -> IO (ForeignPtr Tensor)
 tensor_floor_ = cast1 Unmanaged.tensor_floor_
 
+tensor_floor_divide_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_floor_divide_t = cast2 Unmanaged.tensor_floor_divide_t
+
+tensor_floor_divide__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_floor_divide__t = cast2 Unmanaged.tensor_floor_divide__t
+
+tensor_floor_divide_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_floor_divide_s = cast2 Unmanaged.tensor_floor_divide_s
+
+tensor_floor_divide__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_floor_divide__s = cast2 Unmanaged.tensor_floor_divide__s
+
 tensor_frac
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
@@ -1277,6 +1403,14 @@ tensor_narrow_lll
   -> IO (ForeignPtr Tensor)
 tensor_narrow_lll = cast4 Unmanaged.tensor_narrow_lll
 
+tensor_narrow_ltl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_narrow_ltl = cast4 Unmanaged.tensor_narrow_ltl
+
 tensor_permute_l
   :: ForeignPtr Tensor
   -> ForeignPtr IntArray
@@ -1569,6 +1703,16 @@ tensor_sqrt_
   -> IO (ForeignPtr Tensor)
 tensor_sqrt_ = cast1 Unmanaged.tensor_sqrt_
 
+tensor_square
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_square = cast1 Unmanaged.tensor_square
+
+tensor_square_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_square_ = cast1 Unmanaged.tensor_square_
+
 tensor_std_b
   :: ForeignPtr Tensor
   -> CBool
@@ -1662,6 +1806,30 @@ tensor_rot90_ll
   -> IO (ForeignPtr Tensor)
 tensor_rot90_ll = cast3 Unmanaged.tensor_rot90_ll
 
+tensor_true_divide_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_true_divide_t = cast2 Unmanaged.tensor_true_divide_t
+
+tensor_true_divide__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_true_divide__t = cast2 Unmanaged.tensor_true_divide__t
+
+tensor_true_divide_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_true_divide_s = cast2 Unmanaged.tensor_true_divide_s
+
+tensor_true_divide__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_true_divide__s = cast2 Unmanaged.tensor_true_divide__s
+
 tensor_trunc
   :: ForeignPtr Tensor
   -> IO (ForeignPtr Tensor)
@@ -1887,11 +2055,6 @@ tensor_values
   -> IO (ForeignPtr Tensor)
 tensor_values = cast1 Unmanaged.tensor_values
 
-tensor_numel
-  :: ForeignPtr Tensor
-  -> IO (Int64)
-tensor_numel = cast1 Unmanaged.tensor_numel
-
 tensor_unbind_l
   :: ForeignPtr Tensor
   -> Int64
@@ -2313,6 +2476,30 @@ tensor_ne__t
   -> IO (ForeignPtr Tensor)
 tensor_ne__t = cast2 Unmanaged.tensor_ne__t
 
+tensor_bitwise_and_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_and_s = cast2 Unmanaged.tensor_bitwise_and_s
+
+tensor_bitwise_and_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_and_t = cast2 Unmanaged.tensor_bitwise_and_t
+
+tensor_bitwise_and__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_and__s = cast2 Unmanaged.tensor_bitwise_and__s
+
+tensor_bitwise_and__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_and__t = cast2 Unmanaged.tensor_bitwise_and__t
+
 tensor___and___s
   :: ForeignPtr Tensor
   -> ForeignPtr Scalar
@@ -2337,6 +2524,30 @@ tensor___iand___t
   -> IO (ForeignPtr Tensor)
 tensor___iand___t = cast2 Unmanaged.tensor___iand___t
 
+tensor_bitwise_or_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_or_s = cast2 Unmanaged.tensor_bitwise_or_s
+
+tensor_bitwise_or_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_or_t = cast2 Unmanaged.tensor_bitwise_or_t
+
+tensor_bitwise_or__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_or__s = cast2 Unmanaged.tensor_bitwise_or__s
+
+tensor_bitwise_or__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_or__t = cast2 Unmanaged.tensor_bitwise_or__t
+
 tensor___or___s
   :: ForeignPtr Tensor
   -> ForeignPtr Scalar
@@ -2361,6 +2572,30 @@ tensor___ior___t
   -> IO (ForeignPtr Tensor)
 tensor___ior___t = cast2 Unmanaged.tensor___ior___t
 
+tensor_bitwise_xor_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_xor_s = cast2 Unmanaged.tensor_bitwise_xor_s
+
+tensor_bitwise_xor_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_xor_t = cast2 Unmanaged.tensor_bitwise_xor_t
+
+tensor_bitwise_xor__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_xor__s = cast2 Unmanaged.tensor_bitwise_xor__s
+
+tensor_bitwise_xor__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_xor__t = cast2 Unmanaged.tensor_bitwise_xor__t
+
 tensor___xor___s
   :: ForeignPtr Tensor
   -> ForeignPtr Scalar
diff --git a/libtorch-ffi/src/Torch/Internal/Unmanaged/Autograd.hs b/libtorch-ffi/src/Torch/Internal/Unmanaged/Autograd.hs
index 9014753a1..707e47795 100644
--- a/libtorch-ffi/src/Torch/Internal/Unmanaged/Autograd.hs
+++ b/libtorch-ffi/src/Torch/Internal/Unmanaged/Autograd.hs
@@ -28,7 +28,7 @@ grad y inputs = [C.throwBlock| std::vector<at::Tensor>* {
     torch::autograd::Variable y = *$(at::Tensor* y);
     const auto & inputs = *$(std::vector<at::Tensor>* inputs);
 
-    torch::autograd::edge_list roots { impl::gradient_edge(y) };
+    torch::autograd::edge_list roots { torch::autograd::impl::gradient_edge(y) };
     if (!roots[0].function) {
       throw std::runtime_error("Differentiated tensor not require grad");
     }
@@ -44,7 +44,7 @@ grad y inputs = [C.throwBlock| std::vector<at::Tensor>* {
       const auto output_nr = input.output_nr();
       auto grad_fn = input.grad_fn();
       if (!grad_fn) {
-        grad_fn = impl::try_get_grad_accumulator(input);
+        grad_fn = torch::autograd::impl::try_get_grad_accumulator(input);
       }
       if (!input.requires_grad()) {
         throw std::runtime_error("One of the differentiated Tensors does not require grad");
diff --git a/libtorch-ffi/src/Torch/Internal/Unmanaged/Native.hs b/libtorch-ffi/src/Torch/Internal/Unmanaged/Native.hs
index 3f8939ead..b50d6e209 100644
--- a/libtorch-ffi/src/Torch/Internal/Unmanaged/Native.hs
+++ b/libtorch-ffi/src/Torch/Internal/Unmanaged/Native.hs
@@ -601,16 +601,6 @@ real_t _self =
     *$(at::Tensor* _self)));
   }|]
 
-real_out_tt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-real_out_tt _out _self =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::real_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)));
-  }|]
-
 imag_t
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -619,16 +609,6 @@ imag_t _self =
     *$(at::Tensor* _self)));
   }|]
 
-imag_out_tt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-imag_out_tt _out _self =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::imag_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)));
-  }|]
-
 conj_t
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -1795,6 +1775,28 @@ batch_norm_tttttbddb _input _weight _bias _running_mean _running_var _training _
   , $(bool _cudnn_enabled)));
   }|]
 
+quantized_batch_norm_tttttddl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+quantized_batch_norm_tttttddl _input _weight _bias _mean _var _eps _output_scale _output_zero_point =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_batch_norm(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _var)
+  , $(double _eps)
+  , $(double _output_scale)
+  , $(int64_t _output_zero_point)));
+  }|]
+
 _batch_norm_impl_index_tttttbddb
   :: Ptr Tensor
   -> Ptr Tensor
@@ -1925,6 +1927,174 @@ bilinear_tttt _input1 _input2 _weight _bias =
   , *$(at::Tensor* _bias)));
   }|]
 
+binary_cross_entropy_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+binary_cross_entropy_tttl _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+binary_cross_entropy_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_ttt _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+binary_cross_entropy_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+binary_cross_entropy_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+binary_cross_entropy_out_ttttl _out _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+binary_cross_entropy_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_out_tttt _out _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+binary_cross_entropy_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+binary_cross_entropy_backward_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+binary_cross_entropy_backward_ttttl _grad_output _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+binary_cross_entropy_backward_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_backward_tttt _grad_output _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+binary_cross_entropy_backward_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_backward_ttt _grad_output _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+binary_cross_entropy_backward_out_tttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+binary_cross_entropy_backward_out_tttttl _grad_input _grad_output _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+binary_cross_entropy_backward_out_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_backward_out_ttttt _grad_input _grad_output _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+binary_cross_entropy_backward_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_backward_out_tttt _grad_input _grad_output _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
 binary_cross_entropy_with_logits_ttttl
   :: Ptr Tensor
   -> Ptr Tensor
@@ -2125,6 +2295,50 @@ logical_xor_out_ttt _out _self _other =
   , *$(at::Tensor* _other)));
   }|]
 
+logical_and_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logical_and_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logical_and(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+logical_and_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logical_and_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logical_and_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+logical_or_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logical_or_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logical_or(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+logical_or_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logical_or_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logical_or_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
 blackman_window_lo
   :: Int64
   -> Ptr TensorOptions
@@ -3533,6 +3747,28 @@ cudnn_convolution_tttllllbb _self _weight _bias _padding _stride _dilation _grou
   , $(bool _deterministic)));
   }|]
 
+cudnn_convolution_ttllllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+cudnn_convolution_ttllllbb _self _weight _padding _stride _dilation _groups _benchmark _deterministic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)));
+  }|]
+
 cudnn_convolution_backward_input_lttllllbb
   :: Ptr IntArray
   -> Ptr Tensor
@@ -3567,10 +3803,10 @@ cudnn_convolution_backward_tttllllbba
   -> Int64
   -> CBool
   -> CBool
-  -> Ptr (StdArray '(CBool,3))
-  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
 cudnn_convolution_backward_tttllllbba _self _grad_output _weight _padding _stride _dilation _groups _benchmark _deterministic _output_mask =
-  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::cudnn_convolution_backward(
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cudnn_convolution_backward(
     *$(at::Tensor* _self)
   , *$(at::Tensor* _grad_output)
   , *$(at::Tensor* _weight)
@@ -3580,15 +3816,7 @@ cudnn_convolution_backward_tttllllbba _self _grad_output _weight _padding _strid
   , $(int64_t _groups)
   , $(bool _benchmark)
   , $(bool _deterministic)
-  , *$(std::array<bool,3>* _output_mask)));
-  }|]
-
-cudnn_convolution_backward_bias_t
-  :: Ptr Tensor
-  -> IO (Ptr Tensor)
-cudnn_convolution_backward_bias_t _grad_output =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_backward_bias(
-    *$(at::Tensor* _grad_output)));
+  , *$(std::array<bool,2>* _output_mask)));
   }|]
 
 cudnn_convolution_backward_weight_lttllllbb
@@ -3641,6 +3869,30 @@ cudnn_convolution_transpose_tttlllllbb _self _weight _bias _padding _output_padd
   , $(bool _deterministic)));
   }|]
 
+cudnn_convolution_transpose_ttlllllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+cudnn_convolution_transpose_ttlllllbb _self _weight _padding _output_padding _stride _dilation _groups _benchmark _deterministic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_transpose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)));
+  }|]
+
 cudnn_convolution_transpose_backward_tttlllllbba
   :: Ptr Tensor
   -> Ptr Tensor
@@ -3652,10 +3904,10 @@ cudnn_convolution_transpose_backward_tttlllllbba
   -> Int64
   -> CBool
   -> CBool
-  -> Ptr (StdArray '(CBool,3))
-  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
 cudnn_convolution_transpose_backward_tttlllllbba _self _grad_output _weight _padding _output_padding _stride _dilation _groups _benchmark _deterministic _output_mask =
-  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::cudnn_convolution_transpose_backward(
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cudnn_convolution_transpose_backward(
     *$(at::Tensor* _self)
   , *$(at::Tensor* _grad_output)
   , *$(at::Tensor* _weight)
@@ -3666,15 +3918,7 @@ cudnn_convolution_transpose_backward_tttlllllbba _self _grad_output _weight _pad
   , $(int64_t _groups)
   , $(bool _benchmark)
   , $(bool _deterministic)
-  , *$(std::array<bool,3>* _output_mask)));
-  }|]
-
-cudnn_convolution_transpose_backward_bias_t
-  :: Ptr Tensor
-  -> IO (Ptr Tensor)
-cudnn_convolution_transpose_backward_bias_t _grad_output =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_transpose_backward_bias(
-    *$(at::Tensor* _grad_output)));
+  , *$(std::array<bool,2>* _output_mask)));
   }|]
 
 cudnn_convolution_transpose_backward_input_ttllllbb
@@ -3745,193 +3989,317 @@ cudnn_grid_sampler_backward_ttt _self _grid _grad_output =
   , *$(at::Tensor* _grad_output)));
   }|]
 
-cumsum_tls
+cummax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cummax_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cummax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+cummax_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cummax_out_tttl _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cummax_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+cummax_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cummax_tn _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cummax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+cummax_out_tttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cummax_out_tttn _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cummax_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+_cummax_helper_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (())
+_cummax_helper_tttl _self _values _indices _dim =
+  [C.throwBlock| void {  (at::_cummax_helper(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _dim)));
+  }|]
+
+cummin_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cummin_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cummin(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+cummin_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cummin_out_tttl _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cummin_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+cummin_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cummin_tn _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cummin(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+cummin_out_tttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cummin_out_tttn _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cummin_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+_cummin_helper_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (())
+_cummin_helper_tttl _self _values _indices _dim =
+  [C.throwBlock| void {  (at::_cummin_helper(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _dim)));
+  }|]
+
+cumprod_tls
   :: Ptr Tensor
   -> Int64
   -> ScalarType
   -> IO (Ptr Tensor)
-cumsum_tls _self _dim _dtype =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
+cumprod_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
     *$(at::Tensor* _self)
   , $(int64_t _dim)
   , $(at::ScalarType _dtype)));
   }|]
 
-cumsum_tl
+cumprod_tl
   :: Ptr Tensor
   -> Int64
   -> IO (Ptr Tensor)
-cumsum_tl _self _dim =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
+cumprod_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
     *$(at::Tensor* _self)
   , $(int64_t _dim)));
   }|]
 
-cumsum_out_ttls
+cumprod_out_ttls
   :: Ptr Tensor
   -> Ptr Tensor
   -> Int64
   -> ScalarType
   -> IO (Ptr Tensor)
-cumsum_out_ttls _out _self _dim _dtype =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum_out(
+cumprod_out_ttls _out _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , $(int64_t _dim)
   , $(at::ScalarType _dtype)));
   }|]
 
-cumsum_out_ttl
+cumprod_out_ttl
   :: Ptr Tensor
   -> Ptr Tensor
   -> Int64
   -> IO (Ptr Tensor)
-cumsum_out_ttl _out _self _dim =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum_out(
+cumprod_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , $(int64_t _dim)));
   }|]
 
-cumsum_tns
+cumprod_tns
   :: Ptr Tensor
   -> Ptr Dimname
   -> ScalarType
   -> IO (Ptr Tensor)
-cumsum_tns _self _dim _dtype =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
+cumprod_tns _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
     *$(at::Tensor* _self)
   , *$(at::Dimname* _dim)
   , $(at::ScalarType _dtype)));
   }|]
 
-cumsum_tn
+cumprod_tn
   :: Ptr Tensor
   -> Ptr Dimname
   -> IO (Ptr Tensor)
-cumsum_tn _self _dim =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
+cumprod_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
     *$(at::Tensor* _self)
   , *$(at::Dimname* _dim)));
   }|]
 
-cumsum_out_ttns
+cumprod_out_ttns
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Dimname
   -> ScalarType
   -> IO (Ptr Tensor)
-cumsum_out_ttns _out _self _dim _dtype =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum_out(
+cumprod_out_ttns _out _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , *$(at::Dimname* _dim)
   , $(at::ScalarType _dtype)));
   }|]
 
-cumsum_out_ttn
+cumprod_out_ttn
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Dimname
   -> IO (Ptr Tensor)
-cumsum_out_ttn _out _self _dim =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum_out(
+cumprod_out_ttn _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , *$(at::Dimname* _dim)));
   }|]
 
-cumprod_tls
+cumsum_tls
   :: Ptr Tensor
   -> Int64
   -> ScalarType
   -> IO (Ptr Tensor)
-cumprod_tls _self _dim _dtype =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
+cumsum_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
     *$(at::Tensor* _self)
   , $(int64_t _dim)
   , $(at::ScalarType _dtype)));
   }|]
 
-cumprod_tl
+cumsum_tl
   :: Ptr Tensor
   -> Int64
   -> IO (Ptr Tensor)
-cumprod_tl _self _dim =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
+cumsum_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
     *$(at::Tensor* _self)
   , $(int64_t _dim)));
   }|]
 
-cumprod_out_ttls
+cumsum_out_ttls
   :: Ptr Tensor
   -> Ptr Tensor
   -> Int64
   -> ScalarType
   -> IO (Ptr Tensor)
-cumprod_out_ttls _out _self _dim _dtype =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_out(
+cumsum_out_ttls _out _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , $(int64_t _dim)
   , $(at::ScalarType _dtype)));
   }|]
 
-cumprod_out_ttl
+cumsum_out_ttl
   :: Ptr Tensor
   -> Ptr Tensor
   -> Int64
   -> IO (Ptr Tensor)
-cumprod_out_ttl _out _self _dim =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_out(
+cumsum_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , $(int64_t _dim)));
   }|]
 
-cumprod_tns
+cumsum_tns
   :: Ptr Tensor
   -> Ptr Dimname
   -> ScalarType
   -> IO (Ptr Tensor)
-cumprod_tns _self _dim _dtype =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
+cumsum_tns _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
     *$(at::Tensor* _self)
   , *$(at::Dimname* _dim)
   , $(at::ScalarType _dtype)));
   }|]
 
-cumprod_tn
+cumsum_tn
   :: Ptr Tensor
   -> Ptr Dimname
   -> IO (Ptr Tensor)
-cumprod_tn _self _dim =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
+cumsum_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
     *$(at::Tensor* _self)
   , *$(at::Dimname* _dim)));
   }|]
 
-cumprod_out_ttns
+cumsum_out_ttns
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Dimname
   -> ScalarType
   -> IO (Ptr Tensor)
-cumprod_out_ttns _out _self _dim _dtype =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_out(
+cumsum_out_ttns _out _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , *$(at::Dimname* _dim)
   , $(at::ScalarType _dtype)));
   }|]
 
-cumprod_out_ttn
+cumsum_out_ttn
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Dimname
   -> IO (Ptr Tensor)
-cumprod_out_ttn _out _self _dim =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_out(
+cumsum_out_ttn _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , *$(at::Dimname* _dim)));
@@ -4281,6 +4649,36 @@ diagonal_t _self =
     *$(at::Tensor* _self)));
   }|]
 
+diagonal_tnnnl
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_tnnnl _self _outdim _dim1 _dim2 _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _outdim)
+  , *$(at::Dimname* _dim1)
+  , *$(at::Dimname* _dim2)
+  , $(int64_t _offset)));
+  }|]
+
+diagonal_tnnn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+diagonal_tnnn _self _outdim _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _outdim)
+  , *$(at::Dimname* _dim1)
+  , *$(at::Dimname* _dim2)));
+  }|]
+
 div_tt
   :: Ptr Tensor
   -> Ptr Tensor
@@ -4461,7 +4859,7 @@ embedding_sparse_backward_ttllb _grad _indices _num_weights _padding_idx _scale_
   , $(bool _scale_grad_by_freq)));
   }|]
 
-embedding_bag_tttblbt
+embedding_bag_tttblbtb
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Tensor
@@ -4469,8 +4867,9 @@ embedding_bag_tttblbt
   -> Int64
   -> CBool
   -> Ptr Tensor
+  -> CBool
   -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
-embedding_bag_tttblbt _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights =
+embedding_bag_tttblbtb _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset =
   [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::embedding_bag(
     *$(at::Tensor* _weight)
   , *$(at::Tensor* _indices)
@@ -4478,18 +4877,39 @@ embedding_bag_tttblbt _weight _indices _offsets _scale_grad_by_freq _mode _spars
   , $(bool _scale_grad_by_freq)
   , $(int64_t _mode)
   , $(bool _sparse)
-  , *$(at::Tensor* _per_sample_weights)));
+  , *$(at::Tensor* _per_sample_weights)
+  , $(bool _include_last_offset)));
   }|]
 
-embedding_bag_tttblb
+embedding_bag_tttblbt
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Tensor
   -> CBool
   -> Int64
   -> CBool
+  -> Ptr Tensor
   -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
-embedding_bag_tttblb _weight _indices _offsets _scale_grad_by_freq _mode _sparse =
+embedding_bag_tttblbt _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::embedding_bag(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)
+  , *$(at::Tensor* _per_sample_weights)));
+  }|]
+
+embedding_bag_tttblb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttblb _weight _indices _offsets _scale_grad_by_freq _mode _sparse =
   [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::embedding_bag(
     *$(at::Tensor* _weight)
   , *$(at::Tensor* _indices)
@@ -4541,6 +4961,28 @@ embedding_bag_ttt _weight _indices _offsets =
   , *$(at::Tensor* _offsets)));
   }|]
 
+_embedding_bag_tttblbtb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttblbtb _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_embedding_bag(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)
+  , *$(at::Tensor* _per_sample_weights)
+  , $(bool _include_last_offset)));
+  }|]
+
 _embedding_bag_tttblbt
   :: Ptr Tensor
   -> Ptr Tensor
@@ -4913,24 +5355,6 @@ empty_out_tl _out _size =
   , *$(std::vector<int64_t>* _size)));
   }|]
 
-empty_like_tM
-  :: Ptr Tensor
-  -> MemoryFormat
-  -> IO (Ptr Tensor)
-empty_like_tM _self _memory_format =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_like(
-    *$(at::Tensor* _self)
-  , $(at::MemoryFormat _memory_format)));
-  }|]
-
-empty_like_t
-  :: Ptr Tensor
-  -> IO (Ptr Tensor)
-empty_like_t _self =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_like(
-    *$(at::Tensor* _self)));
-  }|]
-
 empty_like_toM
   :: Ptr Tensor
   -> Ptr TensorOptions
@@ -4953,6 +5377,14 @@ empty_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+empty_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+empty_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 empty_strided_llo
   :: Ptr IntArray
   -> Ptr IntArray
@@ -5257,6 +5689,38 @@ floor_out_tt _out _self =
   , *$(at::Tensor* _self)));
   }|]
 
+floor_divide_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+floor_divide_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::floor_divide(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+floor_divide_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+floor_divide_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::floor_divide_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+floor_divide_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+floor_divide_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::floor_divide(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
 frac_t
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -5343,28 +5807,6 @@ full_out_tls _out _size _fill_value =
   , *$(at::Scalar* _fill_value)));
   }|]
 
-full_like_tsM
-  :: Ptr Tensor
-  -> Ptr Scalar
-  -> MemoryFormat
-  -> IO (Ptr Tensor)
-full_like_tsM _self _fill_value _memory_format =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_like(
-    *$(at::Tensor* _self)
-  , *$(at::Scalar* _fill_value)
-  , $(at::MemoryFormat _memory_format)));
-  }|]
-
-full_like_ts
-  :: Ptr Tensor
-  -> Ptr Scalar
-  -> IO (Ptr Tensor)
-full_like_ts _self _fill_value =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_like(
-    *$(at::Tensor* _self)
-  , *$(at::Scalar* _fill_value)));
-  }|]
-
 full_like_tsoM
   :: Ptr Tensor
   -> Ptr Scalar
@@ -5391,6 +5833,16 @@ full_like_tso _self _fill_value _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+full_like_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+full_like_ts _self _fill_value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_like(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _fill_value)));
+  }|]
+
 from_file_sblo
   :: Ptr StdString
   -> CBool
@@ -9003,6 +9455,20 @@ narrow_tlll _self _dim _start _length =
   , $(int64_t _length)));
   }|]
 
+narrow_tltl
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+narrow_tltl _self _dim _start _length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::narrow(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _start)
+  , $(int64_t _length)));
+  }|]
+
 native_batch_norm_tttttbdd
   :: Ptr Tensor
   -> Ptr Tensor
@@ -9025,6 +9491,34 @@ native_batch_norm_tttttbdd _input _weight _bias _running_mean _running_var _trai
   , $(double _eps)));
   }|]
 
+native_batch_norm_out_ttttttttbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_batch_norm_out_ttttttttbdd _out _save_mean _save_invstd _input _weight _bias _running_mean _running_var _training _momentum _eps =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_batch_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_invstd)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _momentum)
+  , $(double _eps)));
+  }|]
+
 batch_norm_stats_td
   :: Ptr Tensor
   -> CDouble
@@ -9323,24 +9817,6 @@ ones_out_tl _out _size =
   , *$(std::vector<int64_t>* _size)));
   }|]
 
-ones_like_tM
-  :: Ptr Tensor
-  -> MemoryFormat
-  -> IO (Ptr Tensor)
-ones_like_tM _self _memory_format =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_like(
-    *$(at::Tensor* _self)
-  , $(at::MemoryFormat _memory_format)));
-  }|]
-
-ones_like_t
-  :: Ptr Tensor
-  -> IO (Ptr Tensor)
-ones_like_t _self =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_like(
-    *$(at::Tensor* _self)));
-  }|]
-
 ones_like_toM
   :: Ptr Tensor
   -> Ptr TensorOptions
@@ -9363,6 +9839,14 @@ ones_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+ones_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+ones_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 pairwise_distance_ttddb
   :: Ptr Tensor
   -> Ptr Tensor
@@ -9451,6 +9935,20 @@ cdist_tt _x1 _x2 =
   , *$(at::Tensor* _x2)));
   }|]
 
+_cdist_forward_ttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_cdist_forward_ttdl _x1 _x2 _p _compute_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cdist_forward(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)
+  , $(int64_t _compute_mode)));
+  }|]
+
 _cdist_backward_tttdt
   :: Ptr Tensor
   -> Ptr Tensor
@@ -9727,24 +10225,6 @@ rand_out_tlp _out _size _generator =
   , $(at::Generator * _generator)));
   }|]
 
-rand_like_tM
-  :: Ptr Tensor
-  -> MemoryFormat
-  -> IO (Ptr Tensor)
-rand_like_tM _self _memory_format =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_like(
-    *$(at::Tensor* _self)
-  , $(at::MemoryFormat _memory_format)));
-  }|]
-
-rand_like_t
-  :: Ptr Tensor
-  -> IO (Ptr Tensor)
-rand_like_t _self =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_like(
-    *$(at::Tensor* _self)));
-  }|]
-
 rand_like_toM
   :: Ptr Tensor
   -> Ptr TensorOptions
@@ -9767,6 +10247,14 @@ rand_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+rand_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rand_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 randint_llo
   :: Int64
   -> Ptr IntArray
@@ -9927,108 +10415,82 @@ randint_out_tlllp _out _low _high _size _generator =
   , $(at::Generator * _generator)));
   }|]
 
-randint_like_tlM
+randint_like_tloM
   :: Ptr Tensor
   -> Int64
+  -> Ptr TensorOptions
   -> MemoryFormat
   -> IO (Ptr Tensor)
-randint_like_tlM _self _high _memory_format =
+randint_like_tloM _self _high _options _memory_format =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
     *$(at::Tensor* _self)
   , $(int64_t _high)
+  , *$(at::TensorOptions* _options)
   , $(at::MemoryFormat _memory_format)));
   }|]
 
-randint_like_tl
-  :: Ptr Tensor
-  -> Int64
-  -> IO (Ptr Tensor)
-randint_like_tl _self _high =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
-    *$(at::Tensor* _self)
-  , $(int64_t _high)));
-  }|]
-
-randint_like_tllM
+randint_like_tlo
   :: Ptr Tensor
   -> Int64
-  -> Int64
-  -> MemoryFormat
+  -> Ptr TensorOptions
   -> IO (Ptr Tensor)
-randint_like_tllM _self _low _high _memory_format =
+randint_like_tlo _self _high _options =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
     *$(at::Tensor* _self)
-  , $(int64_t _low)
   , $(int64_t _high)
-  , $(at::MemoryFormat _memory_format)));
+  , *$(at::TensorOptions* _options)));
   }|]
 
-randint_like_tll
+randint_like_tl
   :: Ptr Tensor
   -> Int64
-  -> Int64
   -> IO (Ptr Tensor)
-randint_like_tll _self _low _high =
+randint_like_tl _self _high =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
     *$(at::Tensor* _self)
-  , $(int64_t _low)
   , $(int64_t _high)));
   }|]
 
-randint_like_tloM
+randint_like_tlloM
   :: Ptr Tensor
   -> Int64
+  -> Int64
   -> Ptr TensorOptions
   -> MemoryFormat
   -> IO (Ptr Tensor)
-randint_like_tloM _self _high _options _memory_format =
+randint_like_tlloM _self _low _high _options _memory_format =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
     *$(at::Tensor* _self)
+  , $(int64_t _low)
   , $(int64_t _high)
   , *$(at::TensorOptions* _options)
   , $(at::MemoryFormat _memory_format)));
   }|]
 
-randint_like_tlo
+randint_like_tllo
   :: Ptr Tensor
   -> Int64
+  -> Int64
   -> Ptr TensorOptions
   -> IO (Ptr Tensor)
-randint_like_tlo _self _high _options =
+randint_like_tllo _self _low _high _options =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
     *$(at::Tensor* _self)
+  , $(int64_t _low)
   , $(int64_t _high)
   , *$(at::TensorOptions* _options)));
   }|]
 
-randint_like_tlloM
+randint_like_tll
   :: Ptr Tensor
   -> Int64
   -> Int64
-  -> Ptr TensorOptions
-  -> MemoryFormat
   -> IO (Ptr Tensor)
-randint_like_tlloM _self _low _high _options _memory_format =
+randint_like_tll _self _low _high =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
     *$(at::Tensor* _self)
   , $(int64_t _low)
-  , $(int64_t _high)
-  , *$(at::TensorOptions* _options)
-  , $(at::MemoryFormat _memory_format)));
-  }|]
-
-randint_like_tllo
-  :: Ptr Tensor
-  -> Int64
-  -> Int64
-  -> Ptr TensorOptions
-  -> IO (Ptr Tensor)
-randint_like_tllo _self _low _high _options =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
-    *$(at::Tensor* _self)
-  , $(int64_t _low)
-  , $(int64_t _high)
-  , *$(at::TensorOptions* _options)));
+  , $(int64_t _high)));
   }|]
 
 randn_lo
@@ -10141,24 +10603,6 @@ randn_out_tlp _out _size _generator =
   , $(at::Generator * _generator)));
   }|]
 
-randn_like_tM
-  :: Ptr Tensor
-  -> MemoryFormat
-  -> IO (Ptr Tensor)
-randn_like_tM _self _memory_format =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_like(
-    *$(at::Tensor* _self)
-  , $(at::MemoryFormat _memory_format)));
-  }|]
-
-randn_like_t
-  :: Ptr Tensor
-  -> IO (Ptr Tensor)
-randn_like_t _self =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_like(
-    *$(at::Tensor* _self)));
-  }|]
-
 randn_like_toM
   :: Ptr Tensor
   -> Ptr TensorOptions
@@ -10181,6 +10625,14 @@ randn_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+randn_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+randn_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 randperm_lo
   :: Int64
   -> Ptr TensorOptions
@@ -11549,6 +12001,22 @@ sqrt_out_tt _out _self =
   , *$(at::Tensor* _self)));
   }|]
 
+square_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+square_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::square(
+    *$(at::Tensor* _self)));
+  }|]
+
+square__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+square__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::square_(
+    *$(at::Tensor* _self)));
+  }|]
+
 std_tb
   :: Ptr Tensor
   -> CBool
@@ -12435,6 +12903,38 @@ triplet_margin_loss_ttt _anchor _positive _negative =
   , *$(at::Tensor* _negative)));
   }|]
 
+true_divide_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+true_divide_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::true_divide(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+true_divide_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+true_divide_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::true_divide_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+true_divide_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+true_divide_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::true_divide(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
 trunc_t
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -13149,24 +13649,6 @@ zeros_out_tl _out _size =
   , *$(std::vector<int64_t>* _size)));
   }|]
 
-zeros_like_tM
-  :: Ptr Tensor
-  -> MemoryFormat
-  -> IO (Ptr Tensor)
-zeros_like_tM _self _memory_format =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_like(
-    *$(at::Tensor* _self)
-  , $(at::MemoryFormat _memory_format)));
-  }|]
-
-zeros_like_t
-  :: Ptr Tensor
-  -> IO (Ptr Tensor)
-zeros_like_t _self =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_like(
-    *$(at::Tensor* _self)));
-  }|]
-
 zeros_like_toM
   :: Ptr Tensor
   -> Ptr TensorOptions
@@ -13189,6 +13671,14 @@ zeros_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+zeros_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+zeros_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 _standard_gamma_grad_tt
   :: Ptr Tensor
   -> Ptr Tensor
@@ -15695,6 +16185,50 @@ scatter_add_tntt _self _dim _index _src =
   , *$(at::Tensor* _src)));
   }|]
 
+bitwise_and_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_and_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_and_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_and_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_and_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_and_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_and_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_and_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_and(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_and_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_and_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_and(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
 __and___ts
   :: Ptr Tensor
   -> Ptr Scalar
@@ -15715,6 +16249,50 @@ __and___tt _self _other =
   , *$(at::Tensor* _other)));
   }|]
 
+bitwise_or_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_or_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_or_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_or_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_or_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_or_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_or_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_or_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_or(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_or_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_or_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_or(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
 __or___ts
   :: Ptr Tensor
   -> Ptr Scalar
@@ -19035,6 +19613,36 @@ _std_t _self =
     *$(at::Tensor* _self)));
   }|]
 
+_amp_non_finite_check_and_unscale__ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+_amp_non_finite_check_and_unscale__ttt _self _found_inf _inv_scale =
+  [C.throwBlock| void {  (at::_amp_non_finite_check_and_unscale_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _found_inf)
+  , *$(at::Tensor* _inv_scale)));
+  }|]
+
+_amp_update_scale_tttddl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_amp_update_scale_tttddl _growth_tracker _current_scale _found_inf _scale_growth_factor _scale_backoff_factor _growth_interval =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_amp_update_scale(
+    *$(at::Tensor* _growth_tracker)
+  , *$(at::Tensor* _current_scale)
+  , *$(at::Tensor* _found_inf)
+  , $(double _scale_growth_factor)
+  , $(double _scale_backoff_factor)
+  , $(int64_t _growth_interval)));
+  }|]
+
 _cat_ll
   :: Ptr TensorList
   -> Int64
@@ -19251,250 +19859,82 @@ _min_out_tttl _min _min_indices _self _dim =
   , $(int64_t _dim)));
   }|]
 
-binary_cross_entropy_out_ttttl
+mse_loss_out_tttl
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Tensor
-  -> Ptr Tensor
   -> Int64
   -> IO (Ptr Tensor)
-binary_cross_entropy_out_ttttl _out _self _target _weight _reduction =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_out(
+mse_loss_out_tttl _out _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , *$(at::Tensor* _target)
-  , *$(at::Tensor* _weight)
   , $(int64_t _reduction)));
   }|]
 
-binary_cross_entropy_out_tttt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-binary_cross_entropy_out_tttt _out _self _target _weight =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)
-  , *$(at::Tensor* _weight)));
-  }|]
-
-binary_cross_entropy_out_ttt
+mse_loss_out_ttt
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Tensor
   -> IO (Ptr Tensor)
-binary_cross_entropy_out_ttt _out _self _target =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_out(
+mse_loss_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , *$(at::Tensor* _target)));
   }|]
 
-binary_cross_entropy_tttl
+mse_loss_ttl
   :: Ptr Tensor
   -> Ptr Tensor
-  -> Ptr Tensor
   -> Int64
   -> IO (Ptr Tensor)
-binary_cross_entropy_tttl _self _target _weight _reduction =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy(
+mse_loss_ttl _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss(
     *$(at::Tensor* _self)
   , *$(at::Tensor* _target)
-  , *$(at::Tensor* _weight)
   , $(int64_t _reduction)));
   }|]
 
-binary_cross_entropy_ttt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-binary_cross_entropy_ttt _self _target _weight =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy(
-    *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)
-  , *$(at::Tensor* _weight)));
-  }|]
-
-binary_cross_entropy_tt
+mse_loss_tt
   :: Ptr Tensor
   -> Ptr Tensor
   -> IO (Ptr Tensor)
-binary_cross_entropy_tt _self _target =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy(
+mse_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss(
     *$(at::Tensor* _self)
   , *$(at::Tensor* _target)));
   }|]
 
-binary_cross_entropy_backward_out_tttttl
+mse_loss_backward_out_ttttl
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Tensor
   -> Ptr Tensor
-  -> Ptr Tensor
   -> Int64
   -> IO (Ptr Tensor)
-binary_cross_entropy_backward_out_tttttl _grad_input _grad_output _self _target _weight _reduction =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward_out(
+mse_loss_backward_out_ttttl _grad_input _grad_output _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss_backward_out(
     *$(at::Tensor* _grad_input)
   , *$(at::Tensor* _grad_output)
   , *$(at::Tensor* _self)
   , *$(at::Tensor* _target)
-  , *$(at::Tensor* _weight)
   , $(int64_t _reduction)));
   }|]
 
-binary_cross_entropy_backward_out_ttttt
+mse_loss_backward_tttl
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
+  -> Int64
   -> IO (Ptr Tensor)
-binary_cross_entropy_backward_out_ttttt _grad_input _grad_output _self _target _weight =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward_out(
-    *$(at::Tensor* _grad_input)
-  , *$(at::Tensor* _grad_output)
+mse_loss_backward_tttl _grad_output _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss_backward(
+    *$(at::Tensor* _grad_output)
   , *$(at::Tensor* _self)
   , *$(at::Tensor* _target)
-  , *$(at::Tensor* _weight)));
-  }|]
-
-binary_cross_entropy_backward_out_tttt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-binary_cross_entropy_backward_out_tttt _grad_input _grad_output _self _target =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward_out(
-    *$(at::Tensor* _grad_input)
-  , *$(at::Tensor* _grad_output)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)));
-  }|]
-
-binary_cross_entropy_backward_ttttl
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Int64
-  -> IO (Ptr Tensor)
-binary_cross_entropy_backward_ttttl _grad_output _self _target _weight _reduction =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward(
-    *$(at::Tensor* _grad_output)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)
-  , *$(at::Tensor* _weight)
-  , $(int64_t _reduction)));
-  }|]
-
-binary_cross_entropy_backward_tttt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-binary_cross_entropy_backward_tttt _grad_output _self _target _weight =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward(
-    *$(at::Tensor* _grad_output)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)
-  , *$(at::Tensor* _weight)));
-  }|]
-
-binary_cross_entropy_backward_ttt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-binary_cross_entropy_backward_ttt _grad_output _self _target =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_backward(
-    *$(at::Tensor* _grad_output)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)));
-  }|]
-
-mse_loss_out_tttl
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Int64
-  -> IO (Ptr Tensor)
-mse_loss_out_tttl _out _self _target _reduction =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)
-  , $(int64_t _reduction)));
-  }|]
-
-mse_loss_out_ttt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-mse_loss_out_ttt _out _self _target =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)));
-  }|]
-
-mse_loss_ttl
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Int64
-  -> IO (Ptr Tensor)
-mse_loss_ttl _self _target _reduction =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss(
-    *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)
-  , $(int64_t _reduction)));
-  }|]
-
-mse_loss_tt
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> IO (Ptr Tensor)
-mse_loss_tt _self _target =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss(
-    *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)));
-  }|]
-
-mse_loss_backward_out_ttttl
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Int64
-  -> IO (Ptr Tensor)
-mse_loss_backward_out_ttttl _grad_input _grad_output _self _target _reduction =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss_backward_out(
-    *$(at::Tensor* _grad_input)
-  , *$(at::Tensor* _grad_output)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)
-  , $(int64_t _reduction)));
-  }|]
-
-mse_loss_backward_tttl
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Int64
-  -> IO (Ptr Tensor)
-mse_loss_backward_tttl _grad_output _self _target _reduction =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mse_loss_backward(
-    *$(at::Tensor* _grad_output)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _target)
-  , $(int64_t _reduction)));
+  , $(int64_t _reduction)));
   }|]
 
 l1_loss_out_tttl
@@ -20725,6 +21165,42 @@ glu_backward_ttl _grad_output _self _dim =
   , $(int64_t _dim)));
   }|]
 
+hardsigmoid_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hardsigmoid_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardsigmoid_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+hardsigmoid_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+hardsigmoid_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardsigmoid(
+    *$(at::Tensor* _self)));
+  }|]
+
+hardsigmoid__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+hardsigmoid__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardsigmoid_(
+    *$(at::Tensor* _self)));
+  }|]
+
+hardsigmoid_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hardsigmoid_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardsigmoid_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
 hardtanh_out_ttss
   :: Ptr Tensor
   -> Ptr Tensor
@@ -20891,30 +21367,18 @@ leaky_relu_t _self =
     *$(at::Tensor* _self)));
   }|]
 
-leaky_relu_backward_out_ttts
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Scalar
-  -> IO (Ptr Tensor)
-leaky_relu_backward_out_ttts _grad_input _grad_output _self _negative_slope =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::leaky_relu_backward_out(
-    *$(at::Tensor* _grad_input)
-  , *$(at::Tensor* _grad_output)
-  , *$(at::Tensor* _self)
-  , *$(at::Scalar* _negative_slope)));
-  }|]
-
-leaky_relu_backward_tts
+leaky_relu_backward_ttsb
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Scalar
+  -> CBool
   -> IO (Ptr Tensor)
-leaky_relu_backward_tts _grad_output _self _negative_slope =
+leaky_relu_backward_ttsb _grad_output _self _negative_slope _self_is_result =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::leaky_relu_backward(
     *$(at::Tensor* _grad_output)
   , *$(at::Tensor* _self)
-  , *$(at::Scalar* _negative_slope)));
+  , *$(at::Scalar* _negative_slope)
+  , $(bool _self_is_result)));
   }|]
 
 leaky_relu__ts
@@ -21149,42 +21613,24 @@ rrelu_with_noise_tt _self _noise =
   , *$(at::Tensor* _noise)));
   }|]
 
-rrelu_with_noise_backward_out_ttttssb
+rrelu_with_noise_backward_tttssbb
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr Tensor
-  -> Ptr Tensor
   -> Ptr Scalar
   -> Ptr Scalar
   -> CBool
-  -> IO (Ptr Tensor)
-rrelu_with_noise_backward_out_ttttssb _grad_input _grad_output _self _noise _lower _upper _training =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_backward_out(
-    *$(at::Tensor* _grad_input)
-  , *$(at::Tensor* _grad_output)
-  , *$(at::Tensor* _self)
-  , *$(at::Tensor* _noise)
-  , *$(at::Scalar* _lower)
-  , *$(at::Scalar* _upper)
-  , $(bool _training)));
-  }|]
-
-rrelu_with_noise_backward_tttssb
-  :: Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Tensor
-  -> Ptr Scalar
-  -> Ptr Scalar
   -> CBool
   -> IO (Ptr Tensor)
-rrelu_with_noise_backward_tttssb _grad_output _self _noise _lower _upper _training =
+rrelu_with_noise_backward_tttssbb _grad_output _self _noise _lower _upper _training _self_is_result =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_backward(
     *$(at::Tensor* _grad_output)
   , *$(at::Tensor* _self)
   , *$(at::Tensor* _noise)
   , *$(at::Scalar* _lower)
   , *$(at::Scalar* _upper)
-  , $(bool _training)));
+  , $(bool _training)
+  , $(bool _self_is_result)));
   }|]
 
 rrelu_with_noise__ttssbp
@@ -23007,22 +23453,20 @@ replication_pad3d_backward_ttl _grad_output _self _padding =
   , *$(std::vector<int64_t>* _padding)));
   }|]
 
-_test_optional_float_td
+upsample_linear1d_out_ttlbd
   :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
   -> CDouble
   -> IO (Ptr Tensor)
-_test_optional_float_td _self _scale =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_float(
-    *$(at::Tensor* _self)
-  , $(double _scale)));
-  }|]
-
-_test_optional_float_t
-  :: Ptr Tensor
-  -> IO (Ptr Tensor)
-_test_optional_float_t _self =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_float(
-    *$(at::Tensor* _self)));
+upsample_linear1d_out_ttlbd _out _self _output_size _align_corners _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_linear1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales)));
   }|]
 
 upsample_linear1d_out_ttlb
@@ -23039,6 +23483,20 @@ upsample_linear1d_out_ttlb _out _self _output_size _align_corners =
   , $(bool _align_corners)));
   }|]
 
+upsample_linear1d_tlbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_linear1d_tlbd _self _output_size _align_corners _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_linear1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales)));
+  }|]
+
 upsample_linear1d_tlb
   :: Ptr Tensor
   -> Ptr IntArray
@@ -23051,6 +23509,24 @@ upsample_linear1d_tlb _self _output_size _align_corners =
   , $(bool _align_corners)));
   }|]
 
+upsample_linear1d_backward_out_ttllbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_linear1d_backward_out_ttllbd _grad_input _grad_output _output_size _input_size _align_corners _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_linear1d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales)));
+  }|]
+
 upsample_linear1d_backward_out_ttllb
   :: Ptr Tensor
   -> Ptr Tensor
@@ -23067,6 +23543,22 @@ upsample_linear1d_backward_out_ttllb _grad_input _grad_output _output_size _inpu
   , $(bool _align_corners)));
   }|]
 
+upsample_linear1d_backward_tllbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_linear1d_backward_tllbd _grad_output _output_size _input_size _align_corners _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_linear1d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales)));
+  }|]
+
 upsample_linear1d_backward_tllb
   :: Ptr Tensor
   -> Ptr IntArray
@@ -23081,304 +23573,1160 @@ upsample_linear1d_backward_tllb _grad_output _output_size _input_size _align_cor
   , $(bool _align_corners)));
   }|]
 
-upsample_bilinear2d_out_ttlb
+upsample_bilinear2d_out_ttlbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_out_ttlbdd _out _self _output_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_bilinear2d_out_ttlbd
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr IntArray
   -> CBool
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_bilinear2d_out_ttlb _out _self _output_size _align_corners =
+upsample_bilinear2d_out_ttlbd _out _self _output_size _align_corners _scales_h =
   [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , *$(std::vector<int64_t>* _output_size)
-  , $(bool _align_corners)));
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+upsample_bilinear2d_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_out_ttlb _out _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_bilinear2d_tlbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_tlbdd _self _output_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_bilinear2d_tlbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_tlbd _self _output_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+upsample_bilinear2d_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_tlb _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_bilinear2d_backward_out_ttllbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_backward_out_ttllbdd _grad_input _grad_output _output_size _input_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_bilinear2d_backward_out_ttllbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_backward_out_ttllbd _grad_input _grad_output _output_size _input_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+upsample_bilinear2d_backward_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_bilinear2d_backward_tllbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_backward_tllbdd _grad_output _output_size _input_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_bilinear2d_backward_tllbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_backward_tllbd _grad_output _output_size _input_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+upsample_bilinear2d_backward_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_backward_tllb _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_bicubic2d_out_ttlbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_out_ttlbdd _out _self _output_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_bicubic2d_out_ttlbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_out_ttlbd _out _self _output_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+upsample_bicubic2d_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_out_ttlb _out _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_bicubic2d_tlbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_tlbdd _self _output_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_bicubic2d_tlbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_tlbd _self _output_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+upsample_bicubic2d_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_tlb _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_bicubic2d_backward_out_ttllbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_backward_out_ttllbdd _grad_input _grad_output _output_size _input_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_bicubic2d_backward_out_ttllbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_backward_out_ttllbd _grad_input _grad_output _output_size _input_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+upsample_bicubic2d_backward_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_bicubic2d_backward_tllbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_backward_tllbdd _grad_output _output_size _input_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_bicubic2d_backward_tllbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_backward_tllbd _grad_output _output_size _input_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+upsample_bicubic2d_backward_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_backward_tllb _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_trilinear3d_out_ttlbddd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_out_ttlbddd _out _self _output_size _align_corners _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_trilinear3d_out_ttlbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_out_ttlbdd _out _self _output_size _align_corners _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+upsample_trilinear3d_out_ttlbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_out_ttlbd _out _self _output_size _align_corners _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)));
+  }|]
+
+upsample_trilinear3d_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_out_ttlb _out _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_trilinear3d_tlbddd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_tlbddd _self _output_size _align_corners _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_trilinear3d_tlbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_tlbdd _self _output_size _align_corners _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+upsample_trilinear3d_tlbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_tlbd _self _output_size _align_corners _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)));
+  }|]
+
+upsample_trilinear3d_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_tlb _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_trilinear3d_backward_out_ttllbddd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_backward_out_ttllbddd _grad_input _grad_output _output_size _input_size _align_corners _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_trilinear3d_backward_out_ttllbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_backward_out_ttllbdd _grad_input _grad_output _output_size _input_size _align_corners _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+upsample_trilinear3d_backward_out_ttllbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_backward_out_ttllbd _grad_input _grad_output _output_size _input_size _align_corners _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)));
+  }|]
+
+upsample_trilinear3d_backward_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_trilinear3d_backward_tllbddd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_backward_tllbddd _grad_output _output_size _input_size _align_corners _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_trilinear3d_backward_tllbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_backward_tllbdd _grad_output _output_size _input_size _align_corners _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+upsample_trilinear3d_backward_tllbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_backward_tllbd _grad_output _output_size _input_size _align_corners _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)
+  , $(double _scales_d)));
+  }|]
+
+upsample_trilinear3d_backward_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_backward_tllb _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(bool _align_corners)));
+  }|]
+
+upsample_nearest1d_out_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_nearest1d_out_ttld _out _self _output_size _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales)));
+  }|]
+
+upsample_nearest1d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+upsample_nearest1d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+upsample_nearest1d_tld
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_nearest1d_tld _self _output_size _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales)));
+  }|]
+
+upsample_nearest1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+upsample_nearest1d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+upsample_nearest1d_backward_out_ttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_nearest1d_backward_out_ttlld _grad_input _grad_output _output_size _input_size _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales)));
+  }|]
+
+upsample_nearest1d_backward_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+upsample_nearest1d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+upsample_nearest1d_backward_tlld
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_nearest1d_backward_tlld _grad_output _output_size _input_size _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales)));
+  }|]
+
+upsample_nearest1d_backward_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+upsample_nearest1d_backward_tll _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+upsample_nearest2d_out_ttldd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_nearest2d_out_ttldd _out _self _output_size _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_nearest2d_out_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_nearest2d_out_ttld _out _self _output_size _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_h)));
+  }|]
+
+upsample_nearest2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+upsample_nearest2d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+upsample_nearest2d_tldd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_nearest2d_tldd _self _output_size _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_nearest2d_tld
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+upsample_nearest2d_tld _self _output_size _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_h)));
   }|]
 
-upsample_bilinear2d_tlb
+upsample_nearest2d_tl
   :: Ptr Tensor
   -> Ptr IntArray
-  -> CBool
   -> IO (Ptr Tensor)
-upsample_bilinear2d_tlb _self _output_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d(
+upsample_nearest2d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d(
     *$(at::Tensor* _self)
-  , *$(std::vector<int64_t>* _output_size)
-  , $(bool _align_corners)));
+  , *$(std::vector<int64_t>* _output_size)));
   }|]
 
-upsample_bilinear2d_backward_out_ttllb
+upsample_nearest2d_backward_out_ttlldd
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
-  -> CBool
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_bilinear2d_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_backward_out(
+upsample_nearest2d_backward_out_ttlldd _grad_input _grad_output _output_size _input_size _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_backward_out(
     *$(at::Tensor* _grad_input)
   , *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
   , *$(std::vector<int64_t>* _input_size)
-  , $(bool _align_corners)));
+  , $(double _scales_h)
+  , $(double _scales_w)));
   }|]
 
-upsample_bilinear2d_backward_tllb
+upsample_nearest2d_backward_out_ttlld
   :: Ptr Tensor
+  -> Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
-  -> CBool
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_bilinear2d_backward_tllb _grad_output _output_size _input_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d_backward(
-    *$(at::Tensor* _grad_output)
+upsample_nearest2d_backward_out_ttlld _grad_input _grad_output _output_size _input_size _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
   , *$(std::vector<int64_t>* _input_size)
-  , $(bool _align_corners)));
+  , $(double _scales_h)));
   }|]
 
-upsample_bicubic2d_out_ttlb
+upsample_nearest2d_backward_out_ttll
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr IntArray
-  -> CBool
+  -> Ptr IntArray
   -> IO (Ptr Tensor)
-upsample_bicubic2d_out_ttlb _out _self _output_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)
+upsample_nearest2d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
-  , $(bool _align_corners)));
+  , *$(std::vector<int64_t>* _input_size)));
   }|]
 
-upsample_bicubic2d_tlb
+upsample_nearest2d_backward_tlldd
   :: Ptr Tensor
   -> Ptr IntArray
-  -> CBool
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_bicubic2d_tlb _self _output_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d(
-    *$(at::Tensor* _self)
+upsample_nearest2d_backward_tlldd _grad_output _output_size _input_size _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_backward(
+    *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
-  , $(bool _align_corners)));
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_h)
+  , $(double _scales_w)));
   }|]
 
-upsample_bicubic2d_backward_out_ttllb
+upsample_nearest2d_backward_tlld
   :: Ptr Tensor
-  -> Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
-  -> CBool
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_bicubic2d_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_backward_out(
-    *$(at::Tensor* _grad_input)
-  , *$(at::Tensor* _grad_output)
+upsample_nearest2d_backward_tlld _grad_output _output_size _input_size _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_backward(
+    *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
   , *$(std::vector<int64_t>* _input_size)
-  , $(bool _align_corners)));
+  , $(double _scales_h)));
   }|]
 
-upsample_bicubic2d_backward_tllb
+upsample_nearest2d_backward_tll
   :: Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
-  -> CBool
   -> IO (Ptr Tensor)
-upsample_bicubic2d_backward_tllb _grad_output _output_size _input_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d_backward(
+upsample_nearest2d_backward_tll _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_backward(
     *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
-  , *$(std::vector<int64_t>* _input_size)
-  , $(bool _align_corners)));
+  , *$(std::vector<int64_t>* _input_size)));
   }|]
 
-upsample_trilinear3d_out_ttlb
+upsample_nearest3d_out_ttlddd
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr IntArray
-  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_trilinear3d_out_ttlb _out _self _output_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_out(
+upsample_nearest3d_out_ttlddd _out _self _output_size _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_out(
     *$(at::Tensor* _out)
   , *$(at::Tensor* _self)
   , *$(std::vector<int64_t>* _output_size)
-  , $(bool _align_corners)));
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
   }|]
 
-upsample_trilinear3d_tlb
+upsample_nearest3d_out_ttldd
   :: Ptr Tensor
+  -> Ptr Tensor
   -> Ptr IntArray
-  -> CBool
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_trilinear3d_tlb _self _output_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d(
-    *$(at::Tensor* _self)
+upsample_nearest3d_out_ttldd _out _self _output_size _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
   , *$(std::vector<int64_t>* _output_size)
-  , $(bool _align_corners)));
+  , $(double _scales_d)
+  , $(double _scales_h)));
   }|]
 
-upsample_trilinear3d_backward_out_ttllb
+upsample_nearest3d_out_ttld
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr IntArray
-  -> Ptr IntArray
-  -> CBool
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_trilinear3d_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward_out(
-    *$(at::Tensor* _grad_input)
-  , *$(at::Tensor* _grad_output)
+upsample_nearest3d_out_ttld _out _self _output_size _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
   , *$(std::vector<int64_t>* _output_size)
-  , *$(std::vector<int64_t>* _input_size)
-  , $(bool _align_corners)));
+  , $(double _scales_d)));
   }|]
 
-upsample_trilinear3d_backward_tllb
+upsample_nearest3d_out_ttl
   :: Ptr Tensor
+  -> Ptr Tensor
   -> Ptr IntArray
+  -> IO (Ptr Tensor)
+upsample_nearest3d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+upsample_nearest3d_tlddd
+  :: Ptr Tensor
   -> Ptr IntArray
-  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_trilinear3d_backward_tllb _grad_output _output_size _input_size _align_corners =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d_backward(
-    *$(at::Tensor* _grad_output)
+upsample_nearest3d_tlddd _self _output_size _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d(
+    *$(at::Tensor* _self)
   , *$(std::vector<int64_t>* _output_size)
-  , *$(std::vector<int64_t>* _input_size)
-  , $(bool _align_corners)));
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
   }|]
 
-upsample_nearest1d_out_ttl
+upsample_nearest3d_tldd
   :: Ptr Tensor
-  -> Ptr Tensor
   -> Ptr IntArray
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_nearest1d_out_ttl _out _self _output_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)
-  , *$(std::vector<int64_t>* _output_size)));
+upsample_nearest3d_tldd _self _output_size _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_d)
+  , $(double _scales_h)));
   }|]
 
-upsample_nearest1d_tl
+upsample_nearest3d_tld
   :: Ptr Tensor
   -> Ptr IntArray
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_nearest1d_tl _self _output_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d(
+upsample_nearest3d_tld _self _output_size _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_d)));
+  }|]
+
+upsample_nearest3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+upsample_nearest3d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d(
     *$(at::Tensor* _self)
   , *$(std::vector<int64_t>* _output_size)));
   }|]
 
-upsample_nearest1d_backward_out_ttll
+upsample_nearest3d_backward_out_ttllddd
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_nearest1d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_backward_out(
+upsample_nearest3d_backward_out_ttllddd _grad_input _grad_output _output_size _input_size _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_backward_out(
     *$(at::Tensor* _grad_input)
   , *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
-  , *$(std::vector<int64_t>* _input_size)));
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
   }|]
 
-upsample_nearest1d_backward_tll
+upsample_nearest3d_backward_out_ttlldd
   :: Ptr Tensor
+  -> Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_nearest1d_backward_tll _grad_output _output_size _input_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d_backward(
-    *$(at::Tensor* _grad_output)
+upsample_nearest3d_backward_out_ttlldd _grad_input _grad_output _output_size _input_size _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
-  , *$(std::vector<int64_t>* _input_size)));
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)
+  , $(double _scales_h)));
   }|]
 
-upsample_nearest2d_out_ttl
+upsample_nearest3d_backward_out_ttlld
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr IntArray
-  -> IO (Ptr Tensor)
-upsample_nearest2d_out_ttl _out _self _output_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)
-  , *$(std::vector<int64_t>* _output_size)));
-  }|]
-
-upsample_nearest2d_tl
-  :: Ptr Tensor
   -> Ptr IntArray
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_nearest2d_tl _self _output_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d(
-    *$(at::Tensor* _self)
-  , *$(std::vector<int64_t>* _output_size)));
+upsample_nearest3d_backward_out_ttlld _grad_input _grad_output _output_size _input_size _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)));
   }|]
 
-upsample_nearest2d_backward_out_ttll
+upsample_nearest3d_backward_out_ttll
   :: Ptr Tensor
   -> Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
   -> IO (Ptr Tensor)
-upsample_nearest2d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_backward_out(
+upsample_nearest3d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_backward_out(
     *$(at::Tensor* _grad_input)
   , *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
   , *$(std::vector<int64_t>* _input_size)));
   }|]
 
-upsample_nearest2d_backward_tll
+upsample_nearest3d_backward_tllddd
   :: Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_nearest2d_backward_tll _grad_output _output_size _input_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d_backward(
+upsample_nearest3d_backward_tllddd _grad_output _output_size _input_size _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_backward(
     *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
-  , *$(std::vector<int64_t>* _input_size)));
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
   }|]
 
-upsample_nearest3d_out_ttl
+upsample_nearest3d_backward_tlldd
   :: Ptr Tensor
-  -> Ptr Tensor
   -> Ptr IntArray
-  -> IO (Ptr Tensor)
-upsample_nearest3d_out_ttl _out _self _output_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_out(
-    *$(at::Tensor* _out)
-  , *$(at::Tensor* _self)
-  , *$(std::vector<int64_t>* _output_size)));
-  }|]
-
-upsample_nearest3d_tl
-  :: Ptr Tensor
   -> Ptr IntArray
+  -> CDouble
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_nearest3d_tl _self _output_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d(
-    *$(at::Tensor* _self)
-  , *$(std::vector<int64_t>* _output_size)));
+upsample_nearest3d_backward_tlldd _grad_output _output_size _input_size _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)
+  , $(double _scales_h)));
   }|]
 
-upsample_nearest3d_backward_out_ttll
+upsample_nearest3d_backward_tlld
   :: Ptr Tensor
-  -> Ptr Tensor
   -> Ptr IntArray
   -> Ptr IntArray
+  -> CDouble
   -> IO (Ptr Tensor)
-upsample_nearest3d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
-  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_backward_out(
-    *$(at::Tensor* _grad_input)
-  , *$(at::Tensor* _grad_output)
+upsample_nearest3d_backward_tlld _grad_output _output_size _input_size _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d_backward(
+    *$(at::Tensor* _grad_output)
   , *$(std::vector<int64_t>* _output_size)
-  , *$(std::vector<int64_t>* _input_size)));
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)));
   }|]
 
 upsample_nearest3d_backward_tll
@@ -25047,3 +26395,11 @@ isfinite_t _self =
     *$(at::Tensor* _self)));
   }|]
 
+isinf_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+isinf_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isinf(
+    *$(at::Tensor* _self)));
+  }|]
+
diff --git a/libtorch-ffi/src/Torch/Internal/Unmanaged/TensorFactories.hs b/libtorch-ffi/src/Torch/Internal/Unmanaged/TensorFactories.hs
index 5e32b597f..039e2bc0b 100644
--- a/libtorch-ffi/src/Torch/Internal/Unmanaged/TensorFactories.hs
+++ b/libtorch-ffi/src/Torch/Internal/Unmanaged/TensorFactories.hs
@@ -387,6 +387,14 @@ empty_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+empty_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+empty_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 empty_strided_llo
   :: Ptr IntArray
   -> Ptr IntArray
@@ -523,6 +531,16 @@ full_like_tso _self _fill_value _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+full_like_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+full_like_ts _self _fill_value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::full_like(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _fill_value)));
+  }|]
+
 from_file_sblo
   :: Ptr StdString
   -> CBool
@@ -853,6 +871,14 @@ ones_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+ones_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+ones_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::ones_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 scalar_tensor_so
   :: Ptr Scalar
   -> Ptr TensorOptions
@@ -981,6 +1007,14 @@ rand_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+rand_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rand_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 randint_llo
   :: Int64
   -> Ptr IntArray
@@ -1111,6 +1145,16 @@ randint_like_tlo _self _high _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+randint_like_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+randint_like_tl _self _high =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint_like(
+    *$(at::Tensor* _self)
+  , $(int64_t _high)));
+  }|]
+
 randint_like_tlloM
   :: Ptr Tensor
   -> Int64
@@ -1141,6 +1185,18 @@ randint_like_tllo _self _low _high _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+randint_like_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+randint_like_tll _self _low _high =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint_like(
+    *$(at::Tensor* _self)
+  , $(int64_t _low)
+  , $(int64_t _high)));
+  }|]
+
 randn_lo
   :: Ptr IntArray
   -> Ptr TensorOptions
@@ -1251,6 +1307,14 @@ randn_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+randn_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+randn_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 randperm_lo
   :: Int64
   -> Ptr TensorOptions
@@ -1401,6 +1465,14 @@ zeros_like_to _self _options =
   , *$(at::TensorOptions* _options)));
   }|]
 
+zeros_like_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+zeros_like_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::zeros_like(
+    *$(at::Tensor* _self)));
+  }|]
+
 sparse_coo_tensor_lo
   :: Ptr IntArray
   -> Ptr TensorOptions
diff --git a/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/IValue.hs b/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/IValue.hs
index e44eb7d90..ece6d5c0d 100644
--- a/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/IValue.hs
+++ b/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/IValue.hs
@@ -80,7 +80,7 @@ instance IValueLike (Ptr (C10List IValue)) (Ptr IValue) where
       *$(c10::List<at::IValue>* _x));
     }|]
   fromIValue _obj = 
-    [C.throwBlock| c10::List<at::IValue>* { return new c10::List<at::IValue>((*$(at::IValue* _obj)).toGenericList(
+    [C.throwBlock| c10::List<at::IValue>* { return new c10::List<at::IValue>((*$(at::IValue* _obj)).toList(
       ));
     }|]
 
@@ -402,11 +402,11 @@ iValue_isTensorList _obj =
     );
   }|]
 
-iValue_isGenericList
+iValue_isList
   :: Ptr IValue
   -> IO (CBool)
-iValue_isGenericList _obj =
-  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isGenericList(
+iValue_isList _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isList(
     );
   }|]
 
diff --git a/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/Module.hs b/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/Module.hs
index 2da8e4729..a7b69be99 100644
--- a/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/Module.hs
+++ b/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/Module.hs
@@ -30,7 +30,7 @@ import Data.IORef
 C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
 
 C.include "<torch/script.h>"
-C.include "<torch/csrc/jit/export.h>"
+C.include "<torch/csrc/jit/serialization/export.h>"
 C.include "<vector>"
 C.include "<iostream>"
 
diff --git a/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/Tensor.hs b/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/Tensor.hs
index 3de979d8d..76861f151 100644
--- a/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/Tensor.hs
+++ b/libtorch-ffi/src/Torch/Internal/Unmanaged/Type/Tensor.hs
@@ -90,10 +90,10 @@ tensor_reset _obj =
 tensor__assign__t
   :: Ptr Tensor
   -> Ptr Tensor
-  -> IO (())
+  -> IO (Ptr Tensor)
 tensor__assign__t _obj _x =
-  [C.throwBlock| void {  (*$(at::Tensor* _obj))=(
-    *$(at::Tensor* _x));
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))=(
+    *$(at::Tensor* _x)));
   }|]
 
 tensor_is_same_t
@@ -161,6 +161,14 @@ tensor_is_contiguous _obj =
     );
   }|]
 
+tensor_is_non_overlapping_and_dense
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_non_overlapping_and_dense _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_non_overlapping_and_dense(
+    );
+  }|]
+
 tensor_nbytes
   :: Ptr Tensor
   -> IO (CSize)
@@ -169,6 +177,14 @@ tensor_nbytes _obj =
     );
   }|]
 
+tensor_numel
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_numel _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).numel(
+    );
+  }|]
+
 tensor_itemsize
   :: Ptr Tensor
   -> IO (CSize)
@@ -179,9 +195,9 @@ tensor_itemsize _obj =
 
 tensor_element_size
   :: Ptr Tensor
-  -> IO (CSize)
+  -> IO (Int64)
 tensor_element_size _obj =
-  [C.throwBlock| size_t { return (*$(at::Tensor* _obj)).element_size(
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).element_size(
     );
   }|]
 
@@ -558,6 +574,23 @@ tensor__version _obj =
     );
   }|]
 
+tensor_requires_grad__b
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_requires_grad__b _obj __requires_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).requires_grad_(
+    $(bool __requires_grad)));
+  }|]
+
+tensor_retain_grad
+  :: Ptr Tensor
+  -> IO (())
+tensor_retain_grad _obj =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj)).retain_grad(
+    );
+  }|]
+
 tensor_align_to_N
   :: Ptr Tensor
   -> Ptr DimnameList
@@ -567,6 +600,17 @@ tensor_align_to_N _obj _names =
     *$(std::vector<at::Dimname>* _names)));
   }|]
 
+tensor_align_to_Nl
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_align_to_Nl _obj _order _ellipsis_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).align_to(
+    *$(std::vector<at::Dimname>* _order)
+  , $(int64_t _ellipsis_idx)));
+  }|]
+
 tensor_align_as_t
   :: Ptr Tensor
   -> Ptr Tensor
@@ -627,6 +671,22 @@ tensor_abs_ _obj =
     ));
   }|]
 
+tensor_angle
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_angle _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).angle(
+    ));
+  }|]
+
+tensor_conj
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_conj _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).conj(
+    ));
+  }|]
+
 tensor_acos
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -971,6 +1031,42 @@ tensor_logical_xor__t _obj _other =
     *$(at::Tensor* _other)));
   }|]
 
+tensor_logical_and_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logical_and_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logical_and(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_logical_and__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logical_and__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logical_and_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_logical_or_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logical_or_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logical_or(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_logical_or__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logical_or__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logical_or_(
+    *$(at::Tensor* _other)));
+  }|]
+
 tensor_bmm_t
   :: Ptr Tensor
   -> Ptr Tensor
@@ -1094,6 +1190,42 @@ tensor_cosh_ _obj =
     ));
   }|]
 
+tensor_cummax_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_cummax_l _obj _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).cummax(
+    $(int64_t _dim)));
+  }|]
+
+tensor_cummax_n
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_cummax_n _obj _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).cummax(
+    *$(at::Dimname* _dim)));
+  }|]
+
+tensor_cummin_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_cummin_l _obj _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).cummin(
+    $(int64_t _dim)));
+  }|]
+
+tensor_cummin_n
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_cummin_n _obj _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).cummin(
+    *$(at::Dimname* _dim)));
+  }|]
+
 tensor_det
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -1137,6 +1269,21 @@ tensor_diagonal_lll _obj _offset _dim1 _dim2 =
   , $(int64_t _dim2)));
   }|]
 
+tensor_diagonal_nnnl
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_diagonal_nnnl _obj _outdim _dim1 _dim2 _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).diagonal(
+    *$(at::Dimname* _outdim)
+  , *$(at::Dimname* _dim1)
+  , *$(at::Dimname* _dim2)
+  , $(int64_t _offset)));
+  }|]
+
 tensor_fill_diagonal__sb
   :: Ptr Tensor
   -> Ptr Scalar
@@ -1226,6 +1373,17 @@ tensor_resize__l _obj _size =
     *$(std::vector<int64_t>* _size)));
   }|]
 
+tensor_new_zeros_lo
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+tensor_new_zeros_lo _obj _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).new_zeros(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
 tensor_erf
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -1392,6 +1550,42 @@ tensor_floor_ _obj =
     ));
   }|]
 
+tensor_floor_divide_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_floor_divide_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).floor_divide(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_floor_divide__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_floor_divide__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).floor_divide_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_floor_divide_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_floor_divide_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).floor_divide(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_floor_divide__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_floor_divide__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).floor_divide_(
+    *$(at::Scalar* _other)));
+  }|]
+
 tensor_frac
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -1994,6 +2188,19 @@ tensor_narrow_lll _obj _dim _start _length =
   , $(int64_t _length)));
   }|]
 
+tensor_narrow_ltl
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_narrow_ltl _obj _dim _start _length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).narrow(
+    $(int64_t _dim)
+  , *$(at::Tensor* _start)
+  , $(int64_t _length)));
+  }|]
+
 tensor_permute_l
   :: Ptr Tensor
   -> Ptr IntArray
@@ -2451,6 +2658,22 @@ tensor_sqrt_ _obj =
     ));
   }|]
 
+tensor_square
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_square _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).square(
+    ));
+  }|]
+
+tensor_square_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_square_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).square_(
+    ));
+  }|]
+
 tensor_std_b
   :: Ptr Tensor
   -> CBool
@@ -2598,6 +2821,42 @@ tensor_rot90_ll _obj _k _dims =
   , *$(std::vector<int64_t>* _dims)));
   }|]
 
+tensor_true_divide_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_true_divide_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).true_divide(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_true_divide__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_true_divide__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).true_divide_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_true_divide_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_true_divide_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).true_divide(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_true_divide__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_true_divide__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).true_divide_(
+    *$(at::Scalar* _other)));
+  }|]
+
 tensor_trunc
   :: Ptr Tensor
   -> IO (Ptr Tensor)
@@ -2953,14 +3212,6 @@ tensor_values _obj =
     ));
   }|]
 
-tensor_numel
-  :: Ptr Tensor
-  -> IO (Int64)
-tensor_numel _obj =
-  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).numel(
-    );
-  }|]
-
 tensor_unbind_l
   :: Ptr Tensor
   -> Int64
@@ -3628,6 +3879,42 @@ tensor_ne__t _obj _other =
     *$(at::Tensor* _other)));
   }|]
 
+tensor_bitwise_and_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_and_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_and(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_bitwise_and_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_and_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_and(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_and__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_and__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_and_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_bitwise_and__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_and__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_and_(
+    *$(at::Tensor* _other)));
+  }|]
+
 tensor___and___s
   :: Ptr Tensor
   -> Ptr Scalar
@@ -3664,6 +3951,42 @@ tensor___iand___t _obj _other =
     *$(at::Tensor* _other)));
   }|]
 
+tensor_bitwise_or_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_or_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_or(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_bitwise_or_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_or_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_or(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_or__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_or__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_or_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_bitwise_or__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_or__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_or_(
+    *$(at::Tensor* _other)));
+  }|]
+
 tensor___or___s
   :: Ptr Tensor
   -> Ptr Scalar
@@ -3700,6 +4023,42 @@ tensor___ior___t _obj _other =
     *$(at::Tensor* _other)));
   }|]
 
+tensor_bitwise_xor_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_xor_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_xor(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_bitwise_xor_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_xor_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_xor(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_xor__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_xor__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_xor_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_bitwise_xor__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_xor__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_xor_(
+    *$(at::Tensor* _other)));
+  }|]
+
 tensor___xor___s
   :: Ptr Tensor
   -> Ptr Scalar
diff --git a/nix/shared.nix b/nix/shared.nix
index 7cb10cda4..d92b21801 100644
--- a/nix/shared.nix
+++ b/nix/shared.nix
@@ -5,8 +5,8 @@ let
     let src = pkgs.fetchFromGitHub {
           owner  = "stites";
           repo   = "pytorch-world";
-          rev    = "66de22dadf334bd457c8a596832160d9126e12e1";
-          sha256 = "08w0y5f8x1d2ncv0qmv8a3zymjbzc6ysawldibd1q3h5kgr2aspv";
+          rev    = "6dc929a791918fff065bb40cbc3db8a62beb2a30";
+          sha256 = "140a2l1l1qnf7v2s1lblrr02mc0knsqpi06f25xj3qchpawbjd4c";
     };
     in (pkgs.callPackage "${src}/libtorch/release.nix" { });
 
@@ -14,7 +14,7 @@ let
     inherit (libtorch_src pkgsOld)
       libtorch_cpu
       libtorch_cudatoolkit_9_2
-      libtorch_cudatoolkit_10_1
+      libtorch_cudatoolkit_10_2
     ;
 
     haskell = pkgsOld.haskell // {
@@ -33,20 +33,21 @@ let
                   haskellPackagesNew: haskellPackagesOld: {
                     "libtorch-ffi_${postfix}" =
                         appendConfigureFlag
-                          (overrideCabal
-                            (haskellPackagesOld.callCabal2nix
-                              "libtorch-ffi"
-                              ../libtorch-ffi
-                              { c10 = pkgsNew."libtorch_${postfix}"
-                              ; torch = pkgsNew."libtorch_${postfix}"
-                              ; }
-                            )
-                            (old: {
-                                preConfigure = (old.preConfigure or "") + optionalString isDarwin ''
-                                  sed -i -e 's/-optc-std=c++11 -optc-xc++/-optc-xc++/g' ../libtorch-ffi/libtorch-ffi.cabal;
-                                '';
-                              }
-                            )
+                          (haskellPackagesOld.callCabal2nixWithOptions
+                            "libtorch-ffi"
+                            ../libtorch-ffi
+                            (if postfix == "cpu" then
+                              (if isDarwin then
+                                 "-fgcc"
+                               else
+                                 "")
+                             else
+                               "-fcuda")
+                            { c10 = pkgsNew."libtorch_${postfix}"
+                            ; torch = pkgsNew."libtorch_${postfix}"
+                            ; torch_cpu = pkgsNew."libtorch_${postfix}"
+                            ; ${if postfix == "cpu" then null else "torch_cuda"} = pkgsNew."libtorch_${postfix}"
+                            ; }
                           )
                         "--extra-include-dirs=${pkgsNew."libtorch_${postfix}"}/include/torch/csrc/api/include";
                     "hasktorch_${postfix}" =
@@ -181,38 +182,40 @@ let
                     extension
                     (mkHasktorchExtension "cpu")
                     (mkHasktorchExtension "cudatoolkit_9_2")
-                    (mkHasktorchExtension "cudatoolkit_10_1")
+                    (mkHasktorchExtension "cudatoolkit_10_2")
                   ];
           }
         );
       };
     };
 
-    hasktorch-examples_cudatoolkit_10_1-static = pkgsOld.haskell.lib.justStaticExecutables pkgsNew.haskell.packages."${compiler}".hasktorch-examples_cudatoolkit_10_1;
-    hasktorch-experimental_cudatoolkit_10_1-static = pkgsOld.haskell.lib.justStaticExecutables pkgsNew.haskell.packages."${compiler}".hasktorch-experimental_cudatoolkit_10_1;
+    hasktorch-examples_cudatoolkit_10_2-static = pkgsOld.haskell.lib.justStaticExecutables pkgsNew.haskell.packages."${compiler}".hasktorch-examples_cudatoolkit_10_2;
+    hasktorch-experimental_cudatoolkit_10_2-static = pkgsOld.haskell.lib.justStaticExecutables pkgsNew.haskell.packages."${compiler}".hasktorch-experimental_cudatoolkit_10_2;
 
-    hasktorch-typed-transformer_cudatoolkit_10_1-image = pkgsOld.dockerTools.buildImage {
-      name = "hasktorch-typed-transformer_cudatoolkit_10_1";
+    hasktorch-typed-transformer_cudatoolkit_10_2-image = pkgsOld.dockerTools.buildImage {
+      name = "hasktorch-typed-transformer_cudatoolkit_10_2";
       tag = "latest";
       fromImage = pkgsOld.dockerTools.pullImage {
         imageName = "nvidia/cuda";
-        imageDigest = "sha256:31e2a1ca7b0e1f678fb1dd0c985b4223273f7c0f3dbde60053b371e2a1aee2cd";
-        sha256 = "1bgw7v6xdi6chjds5qvvn596db56r4hkj7dyds5c7pyfsgl74yf3";
+        imageDigest = "sha256:755981b097e20cc02ae6badcc39a03eb62235412d27236472f3520fa8b9967d3";
+        sha256 = "11zg694nzylv7hyzv1gx59ykgprj3kid4191ykwa0s3mi3mm806c";
+        # finalImageName = "nvidia/cuda";
+        # finalImageTag = "10.2-devel";
       };
       config = {
         WorkingDir = "/workingDir";
         Cmd = [
-          "${pkgsNew.hasktorch-examples_cudatoolkit_10_1-static}/bin/typed-transformer"
+          "${pkgsNew.hasktorch-examples_cudatoolkit_10_2-static}/bin/typed-transformer"
         ];
         Env = [
           "LD_LIBRARY_PATH=/usr/local/nvidia/lib:/usr/local/nvidia/lib64"
           "NVIDIA_VISIBLE_DEVICES=all"
-          "NCCL_VERSION=2.4.8"
+          "NCCL_VERSION=2.5.6"
           "LIBRARY_PATH=/usr/local/cuda/lib64/stubs"
-          "CUDA_PKG_VERSION=10-1=10.1.243-1"
-          "CUDA_VERSION=10.1.243"
+          "CUDA_PKG_VERSION=10-2=10.2.89-1"
+          "CUDA_VERSION=10.2.89"
           "NVIDIA_DRIVER_CAPABILITIES=compute,utility"
-          "NVIDIA_REQUIRE_CUDA=cuda>=10.1 brand=tesla,driver>=384,driver<385 brand=tesla,driver>=396,driver<397 brand=tesla,driver>=410,driver<411"
+          "NVIDIA_REQUIRE_CUDA=cuda>=10.2 brand=tesla,driver>=384,driver<385 brand=tesla,driver>=396,driver<397 brand=tesla,driver>=410,driver<411 brand=tesla,driver>=418,driver<419"
           "PATH=/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
         ];
       };
@@ -304,9 +307,9 @@ in
     inherit nullIfDarwin overlayShared;
 
     inherit (pkgs-linux)
-      hasktorch-examples_cudatoolkit_10_1-static
-      hasktorch-experimental_cudatoolkit_10_1-static
-      hasktorch-typed-transformer_cudatoolkit_10_1-image
+      hasktorch-examples_cudatoolkit_10_2-static
+      hasktorch-experimental_cudatoolkit_10_2-static
+      hasktorch-typed-transformer_cudatoolkit_10_2-image
     ;
 
     inherit (base-compiler)
@@ -315,16 +318,16 @@ in
       inline-c-cpp
       libtorch-ffi_cpu
       libtorch-ffi_cudatoolkit_9_2
-      libtorch-ffi_cudatoolkit_10_1
+      libtorch-ffi_cudatoolkit_10_2
       hasktorch_cpu
       hasktorch_cudatoolkit_9_2
-      hasktorch_cudatoolkit_10_1
+      hasktorch_cudatoolkit_10_2
       hasktorch-examples_cpu
       hasktorch-examples_cudatoolkit_9_2
-      hasktorch-examples_cudatoolkit_10_1
+      hasktorch-examples_cudatoolkit_10_2
       hasktorch-experimental_cpu
       hasktorch-experimental_cudatoolkit_9_2
-      hasktorch-experimental_cudatoolkit_10_1
+      hasktorch-experimental_cudatoolkit_10_2
     ;
     hasktorch-docs = (
       (import ./haddock-combine.nix {
@@ -342,15 +345,15 @@ in
     shell-inline-c-cpp                        = (doBenchmark base-compiler.inline-c-cpp).env;
     shell-libtorch-ffi_cpu                    = (doBenchmark base-compiler.libtorch-ffi_cpu                   ).env.overrideAttrs(fixcpath pkgs.libtorch_cpu);
     shell-libtorch-ffi_cudatoolkit_9_2        = (doBenchmark base-compiler.libtorch-ffi_cudatoolkit_9_2       ).env.overrideAttrs(fixcpath pkgs.libtorch_cudatoolkit_9_2);
-    shell-libtorch-ffi_cudatoolkit_10_1       = (doBenchmark base-compiler.libtorch-ffi_cudatoolkit_10_1      ).env.overrideAttrs(fixcpath pkgs.libtorch_cudatoolkit_10_1);
+    shell-libtorch-ffi_cudatoolkit_10_2       = (doBenchmark base-compiler.libtorch-ffi_cudatoolkit_10_2      ).env.overrideAttrs(fixcpath pkgs.libtorch_cudatoolkit_10_2);
     shell-hasktorch_cpu                       = (doBenchmark base-compiler.hasktorch_cpu                      ).env.overrideAttrs(old: altdev-announce pkgs.libtorch_cpu (fixmkl old));
     shell-hasktorch_cudatoolkit_9_2           = (doBenchmark base-compiler.hasktorch_cudatoolkit_9_2          ).env.overrideAttrs(old: altdev-announce pkgs.libtorch_cudatoolkit_9_2 (fixmkl old));
-    shell-hasktorch_cudatoolkit_10_1          = (doBenchmark base-compiler.hasktorch_cudatoolkit_10_1         ).env.overrideAttrs(old: altdev-announce pkgs.libtorch_cudatoolkit_10_1 (fixmkl old));
+    shell-hasktorch_cudatoolkit_10_2          = (doBenchmark base-compiler.hasktorch_cudatoolkit_10_2         ).env.overrideAttrs(old: altdev-announce pkgs.libtorch_cudatoolkit_10_2 (fixmkl old));
     shell-hasktorch-examples_cpu              = (doBenchmark base-compiler.hasktorch-examples_cpu             ).env.overrideAttrs(fixmkl);
     shell-hasktorch-examples_cudatoolkit_9_2  = (doBenchmark base-compiler.hasktorch-examples_cudatoolkit_9_2 ).env.overrideAttrs(fixmkl);
-    shell-hasktorch-examples_cudatoolkit_10_1 = (doBenchmark base-compiler.hasktorch-examples_cudatoolkit_10_1).env.overrideAttrs(fixmkl);
+    shell-hasktorch-examples_cudatoolkit_10_2 = (doBenchmark base-compiler.hasktorch-examples_cudatoolkit_10_2).env.overrideAttrs(fixmkl);
     shell-hasktorch-experimental_cpu              = (doBenchmark base-compiler.hasktorch-experimental_cpu             ).env.overrideAttrs(fixmkl);
     shell-hasktorch-experimental_cudatoolkit_9_2  = (doBenchmark base-compiler.hasktorch-experimental_cudatoolkit_9_2 ).env.overrideAttrs(fixmkl);
-    shell-hasktorch-experimental_cudatoolkit_10_1 = (doBenchmark base-compiler.hasktorch-experimental_cudatoolkit_10_1).env.overrideAttrs(fixmkl);
+    shell-hasktorch-experimental_cudatoolkit_10_2 = (doBenchmark base-compiler.hasktorch-experimental_cudatoolkit_10_2).env.overrideAttrs(fixmkl);
   }
 
diff --git a/spec/cppclass/tensor.yaml b/spec/cppclass/tensor.yaml
index 4f76534dc..7a9a621f0 100644
--- a/spec/cppclass/tensor.yaml
+++ b/spec/cppclass/tensor.yaml
@@ -21,14 +21,14 @@ methods:
 #- names() -> DimnameList
 - ndimension() -> int64_t
 #- is_contiguous(at::MemoryFormat memory_format=at::MemoryFormat::Contiguous) -> bool
+- is_contiguous() -> bool
 - is_non_overlapping_and_dense() -> bool
-#- suggest_memory_format() -> at::MemoryFormat
 - nbytes() -> size_t
 - numel() -> int64_t
 - itemsize() -> size_t
-- element_size() -> size_t
+- element_size() -> int64_t
 #- type() -> DeprecatedTypeProperties
-#- type_set() -> TensorTypeSet
+#- key_set() -> DispatchKeySet
 - scalar_type() -> ScalarType
 - has_storage() -> bool
 - storage() -> Storage
@@ -80,6 +80,12 @@ methods:
 - operator[](Scalar index) -> Tensor
 - operator[](Tensor index) -> Tensor
 - operator[](int64_t index) -> Tensor
+# - index(ArrayRef<at::indexing::TensorIndex> indices) -> Tensor
+# - index(std::initializer_list<at::indexing::TensorIndex> indices) -> Tensor
+# - index_put_(ArrayRef<at::indexing::TensorIndex> indices, Tensor  rhs) -> Tensor
+# - index_put_(ArrayRef<at::indexing::TensorIndex> indices, Scalar v) -> Tensor
+# - index_put_(std::initializer_list<at::indexing::TensorIndex> indices, Tensor  rhs) -> Tensor
+# - index_put_(std::initializer_list<at::indexing::TensorIndex> indices, Scalar v) -> Tensor
 - cpu() -> Tensor
 - cuda() -> Tensor
 - hip() -> Tensor
@@ -93,6 +99,7 @@ methods:
 - output_nr() -> int64_t
 - _version() -> int64_t
 - requires_grad_(bool _requires_grad=true) -> Tensor
+- retain_grad() -> void
 - align_to(DimnameList names) -> Tensor
 - align_to(DimnameList order, int64_t ellipsis_idx) -> Tensor
 - align_as(Tensor  other) -> Tensor
@@ -102,8 +109,6 @@ methods:
 - abs() -> Tensor
 - abs_() -> Tensor
 - angle() -> Tensor
-- real() -> Tensor
-- imag() -> Tensor
 - conj() -> Tensor
 - acos() -> Tensor
 - acos_() -> Tensor
@@ -137,6 +142,10 @@ methods:
 - logical_not_() -> Tensor
 - logical_xor(Tensor  other) -> Tensor
 - logical_xor_(Tensor  other) -> Tensor
+- logical_and(Tensor  other) -> Tensor
+- logical_and_(Tensor  other) -> Tensor
+- logical_or(Tensor  other) -> Tensor
+- logical_or_(Tensor  other) -> Tensor
 - bmm(Tensor  mat2) -> Tensor
 - ceil() -> Tensor
 - ceil_() -> Tensor
@@ -152,10 +161,15 @@ methods:
 - cos_() -> Tensor
 - cosh() -> Tensor
 - cosh_() -> Tensor
+- cummax(int64_t dim) -> (Tensor,Tensor)
+- cummax(Dimname dim) -> (Tensor,Tensor)
+- cummin(int64_t dim) -> (Tensor,Tensor)
+- cummin(Dimname dim) -> (Tensor,Tensor)
 - det() -> Tensor
 - diag_embed(int64_t offset=0, int64_t dim1=-2, int64_t dim2=-1) -> Tensor
 - diagflat(int64_t offset=0) -> Tensor
 - diagonal(int64_t offset=0, int64_t dim1=0, int64_t dim2=1) -> Tensor
+- diagonal(Dimname outdim, Dimname dim1, Dimname dim2, int64_t offset=0) -> Tensor
 - fill_diagonal_(Scalar fill_value, bool wrap=false) -> Tensor
 - div(Tensor  other) -> Tensor
 - div_(Tensor  other) -> Tensor
@@ -184,6 +198,10 @@ methods:
 - fill_(Tensor  value) -> Tensor
 - floor() -> Tensor
 - floor_() -> Tensor
+- floor_divide(Tensor  other) -> Tensor
+- floor_divide_(Tensor  other) -> Tensor
+- floor_divide(Scalar other) -> Tensor
+- floor_divide_(Scalar other) -> Tensor
 - frac() -> Tensor
 - frac_() -> Tensor
 - ger(Tensor  vec2) -> Tensor
@@ -243,6 +261,7 @@ methods:
 - mvlgamma_(int64_t p) -> Tensor
 - narrow_copy(int64_t dim, int64_t start, int64_t length) -> Tensor
 - narrow(int64_t dim, int64_t start, int64_t length) -> Tensor
+- narrow(int64_t dim, Tensor  start, int64_t length) -> Tensor
 - permute(IntArrayRef dims) -> Tensor
 - numpy_T() -> Tensor
 - is_pinned() -> bool
@@ -294,6 +313,8 @@ methods:
 - sum_to_size(IntArrayRef size) -> Tensor
 - sqrt() -> Tensor
 - sqrt_() -> Tensor
+- square() -> Tensor
+- square_() -> Tensor
 - std(bool unbiased=true) -> Tensor
 - std(IntArrayRef dim, bool unbiased=true, bool keepdim=false) -> Tensor
 - std(DimnameList dim, bool unbiased=true, bool keepdim=false) -> Tensor
@@ -309,6 +330,10 @@ methods:
 - flip(IntArrayRef dims) -> Tensor
 - roll(IntArrayRef shifts, IntArrayRef dims={}) -> Tensor
 - rot90(int64_t k=1, IntArrayRef dims={0,1}) -> Tensor
+- true_divide(Tensor  other) -> Tensor
+- true_divide_(Tensor  other) -> Tensor
+- true_divide(Scalar other) -> Tensor
+- true_divide_(Scalar other) -> Tensor
 - trunc() -> Tensor
 - trunc_() -> Tensor
 - type_as(Tensor  other) -> Tensor
@@ -410,10 +435,18 @@ methods:
 - eq_(Tensor  other) -> Tensor
 - ne_(Scalar other) -> Tensor
 - ne_(Tensor  other) -> Tensor
+- bitwise_and(Scalar other) -> Tensor
+- bitwise_and(Tensor  other) -> Tensor
+- bitwise_and_(Scalar other) -> Tensor
+- bitwise_and_(Tensor  other) -> Tensor
 - __and__(Scalar other) -> Tensor
 - __and__(Tensor  other) -> Tensor
 - __iand__(Scalar other) -> Tensor
 - __iand__(Tensor  other) -> Tensor
+- bitwise_or(Scalar other) -> Tensor
+- bitwise_or(Tensor  other) -> Tensor
+- bitwise_or_(Scalar other) -> Tensor
+- bitwise_or_(Tensor  other) -> Tensor
 - __or__(Scalar other) -> Tensor
 - __or__(Tensor  other) -> Tensor
 - __ior__(Scalar other) -> Tensor