diff --git a/csrc/hasktorch_dump.c b/csrc/hasktorch_dump.c
new file mode 100644
--- /dev/null
+++ b/csrc/hasktorch_dump.c
@@ -0,0 +1,44 @@
+#include "Rts.h"
+#include "hasktorch_dump.h"
+
+void
+showCFinalizers(int flag, StgCFinalizerList *list)
+{
+  StgCFinalizerList *head;
+  for (head = list;
+       (StgClosure *)head != &stg_NO_FINALIZER_closure;
+       head = (StgCFinalizerList *)head->link)
+    {
+      showObject(flag, head->ptr, head->fptr);
+    }
+}
+
+void
+showAllCFinalizers(int flag, StgWeak *list)
+{
+  StgWeak *w;
+  for (w = list; w; w = w->link) {
+    // We need to filter out DEAD_WEAK objects, because it's not guaranteed
+    // that the list will not have them when shutting down.
+    // They only get filtered out during GC for the generation they
+    // belong to.
+    // If there's no major GC between the time that the finalizer for the
+    // object from the oldest generation is manually called and shutdown
+    // we end up running the same finalizer twice. See #7170.
+    const StgInfoTable *winfo = w->header.info;
+    if (winfo != &stg_DEAD_WEAK_info) {
+      showCFinalizers(flag,(StgCFinalizerList *)w->cfinalizers);
+    }
+  }
+
+}
+
+void
+showWeakPtrList(int flag){
+  ACQUIRE_LOCK(sm_mutex);
+  shiftObjectMap();
+  for (uint32_t g = 0; g < RtsFlags.GcFlags.generations; g++) {
+    showAllCFinalizers(flag,generations[g].weak_ptr_list);
+  }
+  RELEASE_LOCK(sm_mutex);
+}
diff --git a/csrc/hasktorch_dump.h b/csrc/hasktorch_dump.h
new file mode 100644
--- /dev/null
+++ b/csrc/hasktorch_dump.h
@@ -0,0 +1,3 @@
+extern  void showObject(int flag, void* ptr, void* fptr);
+extern  void shiftObjectMap();
+extern  void showWeakPtrList(int flag);
diff --git a/csrc/hasktorch_finializer.cpp b/csrc/hasktorch_finializer.cpp
new file mode 100644
--- /dev/null
+++ b/csrc/hasktorch_finializer.cpp
@@ -0,0 +1,374 @@
+#include "hasktorch_profile.h"
+#include "hasktorch_finializer.h"
+#include <map>
+
+void delete_tensor(at::Tensor* tensor){
+  delete tensor;
+}
+
+void delete_tensorlist(std::vector<at::Tensor>* tensors){
+  delete tensors;
+}
+
+void delete_tensorindex(at::indexing::TensorIndex* idx){
+  delete idx;
+}
+
+void delete_tensorindexlist(std::vector<at::indexing::TensorIndex>* idxs){
+  delete idxs;
+}
+
+void delete_c10dict(c10::Dict<at::IValue,at::IValue>* object){
+  delete object;
+}
+
+void delete_c10listivalue(c10::List<at::IValue>* object){
+  delete object;
+}
+
+void delete_c10listtensor(c10::List<at::Tensor>* object){
+  delete object;
+}
+
+void delete_c10listoptionaltensor(c10::List<c10::optional<at::Tensor>>* object){
+  delete object;
+}
+
+void delete_c10listdouble(c10::List<double>* object){
+  delete object;
+}
+
+void delete_c10listint(c10::List<int64_t>* object){
+  delete object;
+}
+
+void delete_c10listbool(c10::List<bool>* object){
+  delete object;
+}
+
+void delete_stdvectordouble(std::vector<double>* object){
+  delete object;
+}
+
+void delete_stdvectorint(std::vector<int64_t>* object){
+  delete object;
+}
+
+void delete_stdvectorbool(std::vector<bool>* object){
+  delete object;
+}
+
+void delete_c10tuple(c10::intrusive_ptr<at::ivalue::Tuple>* object){
+  delete object;
+}
+
+void delete_context(at::Context* object){
+  delete object;
+}
+
+void delete_dimname(at::Dimname* object){
+  delete object;
+}
+
+void delete_dimnamelist(std::vector<at::Dimname>* object){
+  delete object;
+}
+
+void delete_generator(at::Generator* object){
+  delete object;
+}
+
+void delete_ivalue(at::IValue* object){
+  delete object;
+}
+
+void delete_ivaluelist(std::vector<at::IValue>* object){
+  delete object;
+}
+
+void delete_intarray(std::vector<int64_t>* object){
+  delete object;
+}
+
+void delete_module(torch::jit::script::Module* object){
+  delete object;
+}
+
+void delete_jitgraph(std::shared_ptr<torch::jit::Graph>* object){
+  delete object;
+}
+
+void delete_jitnode(torch::jit::Node* object){
+  delete object;
+}
+
+void delete_jitvalue(torch::jit::Value* object){
+  delete object;
+}
+
+void delete_scalar(at::Scalar* object){
+  delete object;
+}
+
+void delete_stdarraybool2(std::array<bool,2>* object){
+  delete object;
+}
+
+void delete_stdarraybool3(std::array<bool,3>* object){
+  delete object;
+}
+
+void delete_stdarraybool4(std::array<bool,4>* object){
+  delete object;
+}
+
+void delete_stdstring(std::string* object){
+  delete object;
+}
+
+void delete_storage(at::Storage* object){
+  delete object;
+}
+
+void delete_symbol(at::Symbol* object){
+  delete object;
+}
+
+void delete_tensoroptions(at::TensorOptions* object){
+  delete object;
+}
+
+void delete_tensortensor(std::tuple<at::Tensor,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensortensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensortensortensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensortensortensortensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensortensortensorint64int64int64int64tensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensortensortensorlist(std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* object){
+  delete object;
+}
+
+void delete_tensortensortensortensorint64(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>* object){
+  delete object;
+}
+
+void delete_tensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensorcdoubleint64(std::tuple<at::Tensor,at::Tensor,double,int64_t>* object){
+  delete object;
+}
+
+void delete_tensortensorint64int64tensor(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensorint64int64tensortensor(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensorlisttensor(std::tuple<std::vector<at::Tensor>,at::Tensor>* object){
+  delete object;
+}
+
+void delete_tensortensorlist(std::tuple<at::Tensor,std::vector<at::Tensor>>* object){
+  delete object;
+}
+
+void delete_tensortensorlisttensorlist(std::tuple<at::Tensor,std::vector<at::Tensor>,std::vector<at::Tensor>>* object){
+  delete object;
+}
+
+void delete_tensorlisttensorlisttensorlisttensorlisttensorlist(std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* object){
+  delete object;
+}
+
+void delete_cdoubleint64(std::tuple<double,int64_t>* object){
+  delete object;
+}
+
+void delete_cdoublecdouble(std::tuple<double,double>* object){
+  delete object;
+}
+
+void delete_tensorgenerator(std::tuple<at::Tensor,at::Generator>* object){
+  delete object;
+}
+
+void delete_optimizer(torch::optim::Optimizer* object){
+  delete object;
+}
+
+void delete_stream(c10::Stream* object){
+  delete object;
+}
+
+void delete_arrayrefscalar(at::ArrayRef<at::Scalar>* object){
+  delete object;
+}
+
+void delete_vectorscalar(std::vector<at::Scalar>* object){
+  delete object;
+}
+
+std::map<void*,int> objectAge;
+std::map<void*,int> prevObjectAge;
+
+void
+shiftObjectMap(){
+  prevObjectAge = objectAge;
+  objectAge = std::map<void*,int>();
+}
+
+void
+showObject(int flag, void* ptr, void* fptr){
+  auto it = prevObjectAge.find(ptr);
+  int age = 0;
+  if (it != prevObjectAge.end()) {
+    objectAge[ptr] = it->second + 1;
+    age = it->second + 1;
+  } else {
+    objectAge[ptr] = 1;
+    age = 1;
+  }
+  if(flag == 0)
+    return;
+  if(age < flag)
+    return;
+  if(fptr == (void*)delete_tensor){
+    at::Tensor* t = (at::Tensor*) ptr;
+    std::cout << age << ":" << "Tensor " << t->scalar_type() << " " << t->sizes() << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensorlist){
+    std::cout << age << ":" << "[Tensor]" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensorindex){
+    std::cout << age << ":" << "tensorindex" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensorindexlist){
+    std::cout << age << ":" << "[tensorindex]" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_c10dict){
+    std::cout << age << ":" << "c10dict" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_c10listivalue){
+    std::cout << age << ":" << "c10listivalue" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_c10listtensor){
+    std::cout << age << ":" << "c10listtensor" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_c10listoptionaltensor){
+    std::cout << age << ":" << "c10listoptionaltensor" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_c10listdouble){
+    std::cout << age << ":" << "c10listdouble" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_c10listint){
+    std::cout << age << ":" << "c10listint" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_c10listbool){
+    std::cout << age << ":" << "c10listbool" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_stdvectordouble){
+    std::cout << age << ":" << "std::vector<double>" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_stdvectorint){
+    std::cout << age << ":" << "std::vector<int>" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_stdvectorbool){
+    std::cout << age << ":" << "std::vector<bool>" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_c10tuple){
+    std::cout << age << ":" << "c10tuple" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_context){
+    std::cout << age << ":" << "context" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_dimname){
+    std::cout << age << ":" << "dimname" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_dimnamelist){
+    std::cout << age << ":" << "[dimname]" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_generator){
+    std::cout << age << ":" << "generator" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_ivalue){
+    std::cout << age << ":" << "ivalue" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_ivaluelist){
+    std::cout << age << ":" << "[ivalue]" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_intarray){
+    std::cout << age << ":" << "intarray" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_module){
+    std::cout << age << ":" << "module" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_jitgraph){
+    std::cout << age << ":" << "jitgraph" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_jitnode){
+    std::cout << age << ":" << "jitnode" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_jitvalue){
+    std::cout << age << ":" << "jitvalue" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_scalar){
+    std::cout << age << ":" << "scalar" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_stdarraybool2){
+    std::cout << age << ":" << "std::array<bool,2>" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_stdarraybool3){
+    std::cout << age << ":" << "std::array<bool,3>" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_stdarraybool4){
+    std::cout << age << ":" << "std::array<bool,4>" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_stdstring){
+    std::cout << age << ":" << "std::string" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_storage){
+    std::cout << age << ":" << "storage" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_symbol){
+    std::cout << age << ":" << "symbol" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensoroptions){
+    std::cout << age << ":" << "tensoroptions" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensor){
+    std::cout << age << ":" << "(tensor,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensortensortensortensor){
+    std::cout << age << ":" << "(tensor,tensor,tensor,tensor,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensortensortensortensortensor){
+    std::cout << age << ":" << "(tensor,tensor,tensor,tensor,tensor,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensortensortensortensortensortensor){
+    std::cout << age << ":" << "(tensor,tensor,tensor,tensor,tensor,tensor,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensortensortensorint64int64int64int64tensor){
+    std::cout << age << ":" << "(tensor,tensor,tensor,tensor,int,int,int,int,tensor,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensortensortensorlist){
+    std::cout << age << ":" << "(tensor,tensor,tensor,[tensor])" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensortensortensorint64){
+    std::cout << age << ":" << "(tensor,tensor,tensor,tensor,int)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensortensor){
+    std::cout << age << ":" << "(tensor,tensor,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensortensortensor){
+    std::cout << age << ":" << "(tensor,tensor,tensor,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensorcdoubleint64){
+    std::cout << age << ":" << "(tensor,tensor,double,int)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensorint64int64tensor){
+    std::cout << age << ":" << "(tensor,tensor,int,int,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensorint64int64tensortensor){
+    std::cout << age << ":" << "(tensor,tensor,int,int,tensor,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensorlisttensor){
+    std::cout << age << ":" << "(tensorlist,tensor)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensorlist){
+    std::cout << age << ":" << "(tensor,tensorlist)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensortensorlisttensorlist){
+    std::cout << age << ":" << "(tensor,tensorlist,tensorlist)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensorlisttensorlisttensorlisttensorlisttensorlist){
+    std::cout << age << ":" << "(tensorlist,tensorlist,tensorlist,tensorlist,tensorlist)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_cdoubleint64){
+    std::cout << age << ":" << "(double,int)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_cdoublecdouble){
+    std::cout << age << ":" << "(double,double)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_tensorgenerator){
+    std::cout << age << ":" << "(tensor,generator)" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_optimizer){
+    std::cout << age << ":" << "optimizer" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_stream){
+    std::cout << age << ":" << "stream" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_arrayrefscalar){
+    std::cout << age << ":" << "at::ArrayRef<at::Scalar>" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }else if(fptr == (void*)delete_vectorscalar){
+    std::cout << age << ":" << "std::vector<at::Scalar>" << ":" << std::hex << (ptr) << std::dec << std::endl;
+  }
+}
+
diff --git a/csrc/hasktorch_finializer.h b/csrc/hasktorch_finializer.h
new file mode 100644
--- /dev/null
+++ b/csrc/hasktorch_finializer.h
@@ -0,0 +1,132 @@
+#include <ATen/Tensor.h>
+#include <ATen/core/Dict.h>
+#include <ATen/core/List.h>
+#include <ATen/core/ivalue.h>
+#include <ATen/core/Dimname.h>
+#include <ATen/Storage.h>
+#include <ATen/TensorIndexing.h>
+#include <torch/csrc/jit/api/module.h>
+#include <torch/optim.h>
+
+#include <array>
+#include <string>
+#include <tuple>
+#include <vector>
+
+extern "C" {
+  void delete_tensor(at::Tensor* tensor);
+
+  void delete_tensorlist(std::vector<at::Tensor>* tensors);
+
+  void delete_tensorindex(at::indexing::TensorIndex* idx);
+
+  void delete_tensorindexlist(std::vector<at::indexing::TensorIndex>* idxs);
+
+  void delete_c10dict(c10::Dict<at::IValue,at::IValue>* object);
+
+  void delete_c10listivalue(c10::List<at::IValue>* object);
+
+  void delete_c10listtensor(c10::List<at::Tensor>* object);
+
+  void delete_c10listoptionaltensor(c10::List<c10::optional<at::Tensor>>* object);
+
+  void delete_c10listdouble(c10::List<double>* object);
+
+  void delete_c10listint(c10::List<int64_t>* object);
+
+  void delete_c10listbool(c10::List<bool>* object);
+
+  void delete_stdvectordouble(std::vector<double>* object);
+
+  void delete_stdvectorint(std::vector<int64_t>* object);
+
+  void delete_stdvectorbool(std::vector<bool>* object);
+
+  void delete_c10tuple(c10::intrusive_ptr<at::ivalue::Tuple>* object);
+
+  void delete_context(at::Context* object);
+
+  void delete_dimname(at::Dimname* object);
+
+  void delete_dimnamelist(std::vector<at::Dimname>* object);
+
+  void delete_generator(at::Generator* object);
+
+  void delete_ivalue(at::IValue* object);
+
+  void delete_ivaluelist(std::vector<at::IValue>* object);
+
+  void delete_intarray(std::vector<int64_t>* object);
+
+  void delete_module(torch::jit::script::Module* object);
+
+  void delete_jitgraph(std::shared_ptr<torch::jit::Graph>* object);
+
+  void delete_jitnode(torch::jit::Node* object);
+
+  void delete_jitvalue(torch::jit::Value* object);
+
+  void delete_scalar(at::Scalar* object);
+
+  void delete_stdarraybool2(std::array<bool,2>* object);
+
+  void delete_stdarraybool3(std::array<bool,3>* object);
+
+  void delete_stdarraybool4(std::array<bool,4>* object);
+
+  void delete_stdstring(std::string* object);
+
+  void delete_storage(at::Storage* object);
+
+  void delete_symbol(at::Symbol* object);
+
+  void delete_tensoroptions(at::TensorOptions* object);
+
+  void delete_tensortensor(std::tuple<at::Tensor,at::Tensor>* ptr);
+
+  void delete_tensortensortensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* ptr);
+
+  void delete_tensortensortensortensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* ptr);
+
+  void delete_tensortensortensortensortensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* ptr);
+
+  void delete_tensortensortensortensorint64int64int64int64tensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor,at::Tensor>* ptr);
+
+  void delete_tensortensortensortensorlist(std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* ptr);
+
+  void delete_tensortensortensortensorint64(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>* ptr);
+
+  void delete_tensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor>* ptr);
+
+  void delete_tensortensortensortensor(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* ptr);
+
+  void delete_tensortensorcdoubleint64(std::tuple<at::Tensor,at::Tensor,double,int64_t>* ptr);
+
+  void delete_tensortensorint64int64tensor(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor>* ptr);
+
+  void delete_tensortensorint64int64tensortensor(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor,at::Tensor>* ptr);
+
+  void delete_tensorlisttensor(std::tuple<std::vector<at::Tensor>,at::Tensor>* ptr);
+
+  void delete_tensortensorlist(std::tuple<at::Tensor,std::vector<at::Tensor>>* ptr);
+
+  void delete_tensortensorlisttensorlist(std::tuple<at::Tensor,std::vector<at::Tensor>,std::vector<at::Tensor>>* ptr);
+
+  void delete_tensorlisttensorlisttensorlisttensorlisttensorlist(std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* ptr);
+
+  void delete_cdoubleint64(std::tuple<double,int64_t>* ptr);
+
+  void delete_cdoublecdouble(std::tuple<double,double>* ptr);
+
+  void delete_tensorgenerator(std::tuple<at::Tensor,at::Generator>* ptr);
+
+  void delete_optimizer(torch::optim::Optimizer* ptr);
+
+  void delete_stream(c10::Stream* ptr);
+
+  void delete_arrayrefscalar(at::ArrayRef<at::Scalar>* ptr);
+
+  void delete_vectorscalar(std::vector<at::Scalar>* ptr);
+
+#include "hasktorch_dump.h"
+};
diff --git a/libtorch-ffi.cabal b/libtorch-ffi.cabal
new file mode 100644
--- /dev/null
+++ b/libtorch-ffi.cabal
@@ -0,0 +1,205 @@
+cabal-version:       3.0
+name:                libtorch-ffi
+version:             2.0.0.0
+-- The prefix(2.0) of this version("2.0.0.0") is the same as libtorch's one.
+synopsis:            test out alternative options for ffi interface to libtorch 2.x
+homepage:            https://github.com/hasktorch/hasktorch#readme
+license:             BSD-3-Clause
+author:              Austin Huang
+maintainer:          hasktorch@gmail.com
+copyright:           2018 Austin Huang
+category:            Codegen
+build-type:          Simple
+
+Flag cuda
+ Description: A flag to link libtorch_cuda.
+ Default: False
+ Manual: True
+
+Flag rocm
+ Description: A flag to link libtorch_hip.
+ 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
+                    , Torch.Internal.Cast
+                    , Torch.Internal.Class
+                    , Torch.Internal.Objects
+                    , Torch.Internal.GC
+                    , Torch.Internal.Unmanaged.Native
+                    , Torch.Internal.Unmanaged.Native.Native0
+                    , Torch.Internal.Unmanaged.Native.Native1
+                    , Torch.Internal.Unmanaged.Native.Native2
+                    , Torch.Internal.Unmanaged.Native.Native3
+                    , Torch.Internal.Unmanaged.Native.Native4
+                    , Torch.Internal.Unmanaged.Native.Native5
+                    , Torch.Internal.Unmanaged.Native.Native6
+                    , Torch.Internal.Unmanaged.Native.Native7
+                    , Torch.Internal.Unmanaged.Native.Native8
+                    , Torch.Internal.Unmanaged.Native.Native9
+                    , Torch.Internal.Unmanaged.Native.Native10
+                    , Torch.Internal.Unmanaged.Native.Native11
+                    , Torch.Internal.Unmanaged.Native.Native12
+                    , Torch.Internal.Unmanaged.Native.Native13
+                    , Torch.Internal.Unmanaged.Native.Native14
+                    , Torch.Internal.Unmanaged.Native.Native15
+                    , Torch.Internal.Unmanaged.Native.Extra
+                    , Torch.Internal.Unmanaged.Type.Tuple
+                    , Torch.Internal.Unmanaged.Type.Generator
+                    , Torch.Internal.Unmanaged.Type.IntArray
+                    , Torch.Internal.Unmanaged.Type.Scalar
+                    , Torch.Internal.Unmanaged.Type.Storage
+                    , Torch.Internal.Unmanaged.Type.Tensor
+                    , Torch.Internal.Unmanaged.Type.Tensor.Tensor0
+                    , Torch.Internal.Unmanaged.Type.Tensor.Tensor1
+                    , Torch.Internal.Unmanaged.Type.Tensor.Tensor2
+                    , Torch.Internal.Unmanaged.Type.Tensor.Tensor3
+                    , Torch.Internal.Unmanaged.Type.TensorList
+                    , Torch.Internal.Unmanaged.Type.TensorOptions
+                    , Torch.Internal.Unmanaged.Type.TensorIndex
+                    , Torch.Internal.Unmanaged.Type.StdString
+                    , Torch.Internal.Unmanaged.Type.StdArray
+                    , Torch.Internal.Unmanaged.Type.Context
+--                    , Torch.Internal.Unmanaged.Type.ConstQuantizerPtr
+                    , Torch.Internal.Unmanaged.Type.Extra
+                    , Torch.Internal.Unmanaged.Type.Dimname
+                    , Torch.Internal.Unmanaged.Type.DimnameList
+                    , Torch.Internal.Unmanaged.Type.Symbol
+                    , Torch.Internal.Unmanaged.Type.IValue
+                    , Torch.Internal.Unmanaged.Type.IValueList
+                    , Torch.Internal.Unmanaged.Type.C10List
+                    , Torch.Internal.Unmanaged.Type.C10Dict
+                    , Torch.Internal.Unmanaged.Type.C10Tuple
+                    , Torch.Internal.Unmanaged.Type.Module
+                    , Torch.Internal.Unmanaged.Type.StdVector
+                    , Torch.Internal.Managed.Cast
+                    , Torch.Internal.Managed.Native
+                    , Torch.Internal.Managed.Native.Native0
+                    , Torch.Internal.Managed.Native.Native1
+                    , Torch.Internal.Managed.Native.Native2
+                    , Torch.Internal.Managed.Native.Native3
+                    , Torch.Internal.Managed.Native.Native4
+                    , Torch.Internal.Managed.Native.Native5
+                    , Torch.Internal.Managed.Native.Native6
+                    , Torch.Internal.Managed.Native.Native7
+                    , Torch.Internal.Managed.Native.Native8
+                    , Torch.Internal.Managed.Native.Native9
+                    , Torch.Internal.Managed.Native.Native10
+                    , Torch.Internal.Managed.Native.Native11
+                    , Torch.Internal.Managed.Native.Native12
+                    , Torch.Internal.Managed.Native.Native13
+                    , Torch.Internal.Managed.Native.Native14
+                    , Torch.Internal.Managed.Native.Native15
+                    , Torch.Internal.Managed.Native.Extra
+                    , Torch.Internal.Managed.Type.Tuple
+                    , Torch.Internal.Managed.Type.Generator
+                    , Torch.Internal.Managed.Type.IntArray
+                    , Torch.Internal.Managed.Type.Scalar
+                    , Torch.Internal.Managed.Type.Storage
+                    , Torch.Internal.Managed.Type.Tensor
+                    , Torch.Internal.Managed.Type.Tensor.Tensor0
+                    , Torch.Internal.Managed.Type.Tensor.Tensor1
+                    , Torch.Internal.Managed.Type.Tensor.Tensor2
+                    , Torch.Internal.Managed.Type.Tensor.Tensor3
+                    , Torch.Internal.Managed.Type.TensorList
+                    , Torch.Internal.Managed.Type.TensorIndex
+                    , Torch.Internal.Managed.Type.TensorOptions
+                    , Torch.Internal.Managed.Type.StdString
+                    , Torch.Internal.Managed.Type.StdArray
+                    , Torch.Internal.Managed.Type.Context
+--                    , Torch.Internal.Managed.Type.ConstQuantizerPtr
+                    , Torch.Internal.Managed.Type.Extra
+                    , Torch.Internal.Managed.Type.Dimname
+                    , Torch.Internal.Managed.Type.DimnameList
+                    , Torch.Internal.Managed.Type.Symbol
+                    , Torch.Internal.Managed.Type.IValue
+                    , Torch.Internal.Managed.Type.IValueList
+                    , Torch.Internal.Managed.Type.C10List
+                    , Torch.Internal.Managed.Type.C10Dict
+                    , Torch.Internal.Managed.Type.C10Tuple
+                    , Torch.Internal.Managed.Type.Module
+                    , Torch.Internal.Managed.Type.StdVector
+                    , Torch.Internal.Unmanaged.Autograd
+                    , Torch.Internal.Unmanaged.TensorFactories
+                    , Torch.Internal.Unmanaged.Serialize
+                    , Torch.Internal.Managed.Autograd
+                    , Torch.Internal.Managed.TensorFactories
+                    , Torch.Internal.Managed.Serialize
+                    , Torch.Internal.Unmanaged.Optim
+                    , Torch.Internal.Managed.Optim
+ hs-source-dirs: src
+ default-language: Haskell2010
+ build-depends:       base >= 4.7 && < 5
+                    , inline-c-cpp >= 0.5.0.2 && < 0.6.0.0
+                    , inline-c >= 0.9.1.10 && < 0.10
+                    , optparse-applicative >= 0.14.3.0
+                    , containers
+                    , template-haskell
+                    , bytestring
+                    , safe-exceptions
+                    , sysinfo
+                    , async
+                    , libtorch-ffi-helper >= 0.2.0.0 && < 0.2.0
+ ghc-options:       -fplugin GHC.NotExport.Plugin
+ extra-libraries:     c10
+                    , torch
+                    , torch_cpu
+ if os(darwin)
+  extra-libraries:     c++
+ else
+  extra-libraries:     stdc++
+
+ if flag(cuda)
+  extra-libraries:     torch_cuda
+
+ if flag(rocm)
+  extra-libraries:     c10_hip
+                     , torch_hip
+                     , sqlite3
+                     , tinfo
+                     , bz2
+                     , z
+  ghc-options:       -optcxx-D_GLIBCXX_USE_CXX11_ABI=0
+  cxx-options:       -D_GLIBCXX_USE_CXX11_ABI=0
+
+ extra-ghci-libraries: stdc++
+ if os(darwin)
+  ld-options: -Wl,-keep_dwarf_unwind
+  cpp-options: -DENABLE_DUMMY_MALLOC_TRIM
+  if !flag(gcc)
+    cxx-options:       -std=c++17
+    ghc-options:       -optcxx-std=c++17
+ default-extensions:          Strict
+                            , StrictData
+ cxx-sources:          csrc/hasktorch_finializer.cpp
+ c-sources:            csrc/hasktorch_dump.c
+ install-includes:     csrc/hasktorch_finializer.h
+                      ,csrc/hasktorch_dump.h
+ include-dirs:         csrc
+
+test-suite spec
+  type:            exitcode-stdio-1.0
+  hs-source-dirs:  test
+  main-is:         Spec.hs
+  other-modules:   MemorySpec
+                 , BasicSpec
+--  libtorch-1.3 does not work this grad-function. But grad of higher level api works.
+--                 , BackwardSpec
+                 , CudaSpec
+                 , GeneratorSpec
+  default-language: Haskell2010
+  build-depends:       base
+                     , libtorch-ffi
+                     , hspec
+                     , safe-exceptions
+  if os(darwin)
+    ld-options: -Wl,-keep_dwarf_unwind
+  default-extensions:          Strict
+                             , StrictData
diff --git a/src/Torch/Internal/Cast.hs b/src/Torch/Internal/Cast.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Cast.hs
@@ -0,0 +1,1754 @@
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      : ATen.Cast from FFICXX.Runtime.Cast
+-- Copyright   : (c) 2011-2017 Ian-Woo Kim
+--
+-- License     : BSD3
+-- Maintainer  : Junji Hashimoto<junji.hashimoto@gmail.com>
+-- Stability   : experimental
+-- Portability : GHC
+--
+-----------------------------------------------------------------------------
+
+module Torch.Internal.Cast where
+
+import Control.Monad         ((>=>))
+import Data.ByteString.Char8 (ByteString,packCString, useAsCString)
+import Data.String
+import Data.Word
+import Data.Int
+import Foreign.C
+import Foreign.C.String
+import Foreign.ForeignPtr
+import Foreign.Marshal.Array
+import Foreign.Ptr
+import Foreign.Storable
+import Torch.Internal.Class
+import Torch.Internal.GC
+
+instance Castable a a where
+  cast x f = f x
+  {-# INLINE cast #-}
+  uncast x f = f x
+  {-# INLINE uncast #-}
+
+instance Castable Bool CBool where
+  cast x f = f (if x then 1 else 0)
+  {-# INLINE cast #-}
+  uncast x f = f (x /= 0)
+  {-# INLINE uncast #-}
+
+instance Castable Int CInt where
+  cast x f = f (fromIntegral x)
+  {-# INLINE cast #-}
+  uncast x f = f (fromIntegral x)
+  {-# INLINE uncast#-}
+
+instance Castable Int Int64 where
+  cast x f = f (fromIntegral x)
+  {-# INLINE cast #-}
+  -- TODO: Int64 might have a wider range than Int
+  uncast x f = f (fromIntegral x)
+  {-# INLINE uncast #-}
+
+instance Castable Int16 CShort where
+  cast x f = f (fromIntegral x)
+  {-# INLINE cast #-}
+  uncast x f = f (fromIntegral x)
+  {-# INLINE uncast #-}
+
+instance Castable Int8 CChar where
+  cast x f = f (fromIntegral x)
+  {-# INLINE cast #-}
+  uncast x f = f (fromIntegral x)
+  {-# INLINE uncast #-}
+
+instance Castable Word CUInt where
+  cast x f = f (fromIntegral x)
+  {-# INLINE cast #-}
+  uncast x f = f (fromIntegral x)
+  {-# INLINE uncast #-}
+
+instance Castable Word8 CChar where
+  cast x f = f (fromIntegral x)
+  {-# INLINE cast #-}
+  uncast x f = f (fromIntegral x)
+  {-# INLINE uncast #-}
+
+instance Castable Double CDouble where
+  cast x f = f (realToFrac x)
+  {-# INLINE cast #-}
+  uncast x f = f (realToFrac x)
+  {-# INLINE uncast #-}
+
+instance Castable [Double] (Ptr CDouble) where
+  cast xs f = newArray (map realToFrac xs) >>= f
+  {-# INLINE cast #-}
+  uncast xs f = undefined
+  {-# INLINE uncast #-}
+
+instance Castable [Int] (Ptr CInt) where
+  cast xs f = newArray (map fromIntegral xs) >>= f
+  {-# INLINE cast #-}
+  uncast xs f = undefined
+  {-# INLINE uncast #-}
+
+instance Castable ByteString CString where
+  cast x f = useAsCString x f
+  {-# INLINE cast #-}
+  uncast x f = packCString x >>= f
+  {-# INLINE uncast #-}
+
+instance Castable [ByteString] (Ptr CString) where
+  cast xs f = do ys <- mapM (\x -> useAsCString x return) xs
+                 withArray ys $ \cptr -> f cptr
+  {-# INLINE cast #-}
+  uncast xs f = undefined
+  {-# INLINE uncast #-}
+
+instance Castable String CString where
+  cast x f = withCString x f
+  {-# INLINE cast #-}
+  uncast x f = peekCString x >>= f
+  {-# INLINE uncast #-}
+
+instance (Castable a a') => Castable (Maybe a) (Maybe a') where
+  cast Nothing f = f Nothing
+  cast (Just v) f = cast v (\v -> f (Just v))
+  {-# INLINE cast #-}
+  uncast Nothing f = f Nothing
+  uncast (Just v) f = uncast v (\v -> f (Just v)) 
+  {-# INLINE uncast #-}
+
+instance (CppObject a) => Castable (ForeignPtr a) (Ptr a) where
+  cast x f = withForeignPtr x f
+  {-# INLINE cast #-}
+  uncast x f = fromPtr x >>= f
+  {-# INLINE uncast #-}
+
+--------------------------------------------------------------------------------
+-- Tuples of Castable
+--------------------------------------------------------------------------------
+
+instance (Castable a a', Castable b b') => Castable (a,b) (a',b') where
+  cast (t0,t1) f = do
+    t0' <- cast t0 return
+    t1' <- cast t1 return
+    f (t0',t1')
+  uncast (t0,t1) f = do
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    f (t0',t1')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (Castable a a', Castable b b', Castable c c') => Castable (a,b,c) (a',b',c') where
+  cast (t0,t1,t2) f = do
+    t0' <- cast t0 return
+    t1' <- cast t1 return
+    t2' <- cast t2 return
+    f (t0',t1',t2')
+  uncast (t0,t1,t2) f = do
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    f (t0',t1',t2')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (Castable a a', Castable b b', Castable c c', Castable d d') => Castable (a,b,c,d) (a',b',c',d') where
+  cast (t0,t1,t2,t3) f = do
+    t0' <- cast t0 return
+    t1' <- cast t1 return
+    t2' <- cast t2 return
+    t3' <- cast t3 return
+    f (t0',t1',t2',t3')
+  uncast (t0,t1,t2,t3) f = do
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    f (t0',t1',t2',t3')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (Castable a a', Castable b b', Castable c c', Castable d d', Castable e e') => Castable (a,b,c,d,e) (a',b',c',d',e') where
+  cast (t0,t1,t2,t3,t4) f = do
+    t0' <- cast t0 return
+    t1' <- cast t1 return
+    t2' <- cast t2 return
+    t3' <- cast t3 return
+    t4' <- cast t4 return
+    f (t0',t1',t2',t3',t4')
+  uncast (t0,t1,t2,t3,t4) f = do
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    t4' <- uncast t4 return
+    f (t0',t1',t2',t3',t4')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (Castable a a', Castable b b', Castable c c',
+          Castable d d', Castable e e', Castable f f') => Castable (a,b,c,d,e,f) (a',b',c',d',e',f') where
+  cast (t0,t1,t2,t3,t4,t5) f = do
+    t0' <- cast t0 return
+    t1' <- cast t1 return
+    t2' <- cast t2 return
+    t3' <- cast t3 return
+    t4' <- cast t4 return
+    t5' <- cast t5 return
+    f (t0',t1',t2',t3',t4',t5')
+  uncast (t0,t1,t2,t3,t4,t5) f = do
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    t4' <- uncast t4 return
+    t5' <- uncast t5 return
+    f (t0',t1',t2',t3',t4',t5')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+--------------------------------------------------------------------------------
+-- These casts convert the value from C++ Tuple(CppTuple) to Haskell Tuple.
+-- Reverse side is not supported.
+--------------------------------------------------------------------------------
+
+instance (CppTuple2 c, Castable a (A c), Castable b (B c)) => Castable (a,b) c where
+  cast (t0',t1') f = do
+    cast t0' $ \t0 -> 
+      cast t1' $ \t1 -> 
+        makeTuple2 (t0,t1) >>= f
+  uncast t f = do
+    t0 <- get0 t
+    t1 <- get1 t
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    f (t0',t1')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (CppTuple3 d, Castable a (A d), Castable b (B d), Castable c (C d)) => Castable (a,b,c) d where
+  cast _ _ = error "Attempted to cast a 3-tuple from Haskell to C++, this is not supported."
+  uncast t f = do
+    t0 <- get0 t
+    t1 <- get1 t
+    t2 <- get2 t
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    f (t0',t1',t2')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (CppTuple4 e, Castable a (A e), Castable b (B e), Castable c (C e), Castable d (D e)) => Castable (a,b,c,d) e where
+  cast _ _ = error "Attempted to cast a 4-tuple from Haskell to C++, this is not supported."
+  uncast t f = do
+    t0 <- get0 t
+    t1 <- get1 t
+    t2 <- get2 t
+    t3 <- get3 t
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    f (t0',t1',t2',t3')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (CppTuple5 f, Castable a (A f), Castable b (B f), Castable c (C f), Castable d (D f), Castable e (E f)) => Castable (a,b,c,d,e) f where
+  cast _ _ = error "Attempted to cast a 5-tuple from Haskell to C++, this is not supported."
+  uncast t f = do
+    t0 <- get0 t
+    t1 <- get1 t
+    t2 <- get2 t
+    t3 <- get3 t
+    t4 <- get4 t
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    t4' <- uncast t4 return
+    f (t0',t1',t2',t3',t4')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (CppTuple6 g,
+          Castable a (A g), Castable b (B g), Castable c (C g),
+          Castable d (D g), Castable e (E g), Castable f (F g)) => Castable (a,b,c,d,e,f) g where
+  cast _ _ = error "Attempted to cast a 6-tuple from Haskell to C++, this is not supported."
+  uncast t f = do
+    t0 <- get0 t
+    t1 <- get1 t
+    t2 <- get2 t
+    t3 <- get3 t
+    t4 <- get4 t
+    t5 <- get5 t
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    t4' <- uncast t4 return
+    t5' <- uncast t5 return
+    f (t0',t1',t2',t3',t4',t5')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (CppTuple7 h,
+          Castable a (A h), Castable b (B h), Castable c (C h),
+          Castable d (D h), Castable e (E h), Castable f (F h),
+          Castable g (G h)) => Castable (a,b,c,d,e,f,g) h where
+  cast _ _ = error "Attempted to cast a 7-tuple from Haskell to C++, this is not supported."
+  uncast t f = do
+    t0 <- get0 t
+    t1 <- get1 t
+    t2 <- get2 t
+    t3 <- get3 t
+    t4 <- get4 t
+    t5 <- get5 t
+    t6 <- get6 t
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    t4' <- uncast t4 return
+    t5' <- uncast t5 return
+    t6' <- uncast t6 return
+    f (t0',t1',t2',t3',t4',t5',t6')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (CppTuple8 i,
+          Castable a (A i), Castable b (B i), Castable c (C i),
+          Castable d (D i), Castable e (E i), Castable f (F i),
+          Castable g (G i), Castable h (H i)) => Castable (a,b,c,d,e,f,g,h) i where
+  cast _ _ = error "Attempted to cast a 8-tuple from Haskell to C++, this is not supported."
+  uncast t f = do
+    t0 <- get0 t
+    t1 <- get1 t
+    t2 <- get2 t
+    t3 <- get3 t
+    t4 <- get4 t
+    t5 <- get5 t
+    t6 <- get6 t
+    t7 <- get7 t
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    t4' <- uncast t4 return
+    t5' <- uncast t5 return
+    t6' <- uncast t6 return
+    t7' <- uncast t7 return
+    f (t0',t1',t2',t3',t4',t5',t6',t7')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+instance (CppTuple9 j,
+          Castable a (A j), Castable b (B j), Castable c (C j),
+          Castable d (D j), Castable e (E j), Castable f (F j),
+          Castable g (G j), Castable h (H j), Castable i (I j)) => Castable (a,b,c,d,e,f,g,h,i) j where
+  cast _ _ = error "Attempted to cast a 9-tuple from Haskell to C++, this is not supported."
+  uncast t f = do
+    t0 <- get0 t
+    t1 <- get1 t
+    t2 <- get2 t
+    t3 <- get3 t
+    t4 <- get4 t
+    t5 <- get5 t
+    t6 <- get6 t
+    t7 <- get7 t
+    t8 <- get8 t
+    t0' <- uncast t0 return
+    t1' <- uncast t1 return
+    t2' <- uncast t2 return
+    t3' <- uncast t3 return
+    t4' <- uncast t4 return
+    t5' <- uncast t5 return
+    t6' <- uncast t6 return
+    t7' <- uncast t7 return
+    t8' <- uncast t8 return
+    f (t0',t1',t2',t3',t4',t5',t6',t7',t8')
+  {-# INLINE cast #-}
+  {-# INLINE uncast #-}
+
+--------------------------------------------------------------------------------
+-- Cast functions for various numbers of arguments without retryWithGC
+--------------------------------------------------------------------------------
+
+cast0 :: (Castable a ca) => (IO ca) -> IO a
+cast0 f = (f) >>= \ca -> uncast ca return
+
+cast1 :: (Castable a ca, Castable y cy)
+        => (ca -> IO cy) -> a -> IO y
+cast1 f a = 
+  cast a $ \ca ->
+    (f ca ) >>= \cy -> uncast cy return
+
+
+cast2 :: (Castable a ca, Castable x1 cx1, Castable y cy)
+        => (ca -> cx1 -> IO cy) -> a -> x1 -> IO y
+cast2 f a x1 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    (f ca cx1 ) >>= \cy -> uncast cy return
+
+
+cast3 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable y cy)
+        => (ca -> cx1 -> cx2 -> IO cy) -> a -> x1 -> x2 -> IO y
+cast3 f a x1 x2 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    (f ca cx1 cx2 ) >>= \cy -> uncast cy return
+
+
+cast4 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> IO cy) -> a -> x1 -> x2 -> x3 -> IO y
+cast4 f a x1 x2 x3 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    (f ca cx1 cx2 cx3 ) >>= \cy -> uncast cy return
+
+
+cast5 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> IO y
+cast5 f a x1 x2 x3 x4 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    (f ca cx1 cx2 cx3 cx4 ) >>= \cy -> uncast cy return
+
+
+cast6 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> IO y
+cast6 f a x1 x2 x3 x4 x5 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 ) >>= \cy -> uncast cy return
+
+
+cast7 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> IO y
+cast7 f a x1 x2 x3 x4 x5 x6 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 ) >>= \cy -> uncast cy return
+
+
+cast8 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> IO y
+cast8 f a x1 x2 x3 x4 x5 x6 x7 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 ) >>= \cy -> uncast cy return
+
+
+cast9 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> IO y
+cast9 f a x1 x2 x3 x4 x5 x6 x7 x8 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 ) >>= \cy -> uncast cy return
+
+
+cast10 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> IO y
+cast10 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 ) >>= \cy -> uncast cy return
+
+
+cast11 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> IO y
+cast11 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 ) >>= \cy -> uncast cy return
+
+
+cast12 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> IO y
+cast12 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 ) >>= \cy -> uncast cy return
+
+
+cast13 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> IO y
+cast13 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 ) >>= \cy -> uncast cy return
+
+
+cast14 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> IO y
+cast14 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 ) >>= \cy -> uncast cy return
+
+
+cast15 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> IO y
+cast15 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 ) >>= \cy -> uncast cy return
+
+
+cast16 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> IO y
+cast16 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 ) >>= \cy -> uncast cy return
+
+
+cast17 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> IO y
+cast17 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 ) >>= \cy -> uncast cy return
+
+
+cast18 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> IO y
+cast18 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 ) >>= \cy -> uncast cy return
+
+
+cast19 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> IO y
+cast19 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 ) >>= \cy -> uncast cy return
+
+
+cast20 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> IO y
+cast20 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 ) >>= \cy -> uncast cy return
+
+
+cast21 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> IO y
+cast21 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 ) >>= \cy -> uncast cy return
+
+
+cast22 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> IO y
+cast22 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 ) >>= \cy -> uncast cy return
+
+
+cast23 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> IO y
+cast23 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 ) >>= \cy -> uncast cy return
+
+
+cast24 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> IO y
+cast24 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 ) >>= \cy -> uncast cy return
+
+
+cast25 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> IO y
+cast25 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 ) >>= \cy -> uncast cy return
+
+
+cast26 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> IO y
+cast26 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 ) >>= \cy -> uncast cy return
+
+
+cast27 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable x26 cx26, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> cx26 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> x26 -> IO y
+cast27 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    cast x26 $ \cx26 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 cx26 ) >>= \cy -> uncast cy return
+
+
+cast28 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable x26 cx26, Castable x27 cx27, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> cx26 -> cx27 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> x26 -> x27 -> IO y
+cast28 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    cast x26 $ \cx26 ->
+    cast x27 $ \cx27 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 cx26 cx27 ) >>= \cy -> uncast cy return
+
+
+cast29 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable x26 cx26, Castable x27 cx27, Castable x28 cx28, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> cx26 -> cx27 -> cx28 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> x26 -> x27 -> x28 -> IO y
+cast29 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    cast x26 $ \cx26 ->
+    cast x27 $ \cx27 ->
+    cast x28 $ \cx28 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 cx26 cx27 cx28 ) >>= \cy -> uncast cy return
+
+cast30 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable x26 cx26, Castable x27 cx27, Castable x28 cx28, Castable x29 cx29, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> cx26 -> cx27 -> cx28 -> cx29 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> x26 -> x27 -> x28 -> x29 -> IO y
+cast30 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    cast x26 $ \cx26 ->
+    cast x27 $ \cx27 ->
+    cast x28 $ \cx28 ->
+    cast x29 $ \cx29 ->
+    (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 cx26 cx27 cx28 cx29) >>= \cy -> uncast cy return
+
+{-# INLINE cast0 #-}
+{-# INLINE cast1 #-}
+{-# INLINE cast2 #-}
+{-# INLINE cast3 #-}
+{-# INLINE cast4 #-}
+{-# INLINE cast5 #-}
+{-# INLINE cast6 #-}
+{-# INLINE cast7 #-}
+{-# INLINE cast8 #-}
+{-# INLINE cast9 #-}
+{-# INLINE cast10 #-}
+{-# INLINE cast11 #-}
+{-# INLINE cast12 #-}
+{-# INLINE cast13 #-}
+{-# INLINE cast14 #-}
+{-# INLINE cast15 #-}
+{-# INLINE cast16 #-}
+{-# INLINE cast17 #-}
+{-# INLINE cast18 #-}
+{-# INLINE cast19 #-}
+{-# INLINE cast20 #-}
+{-# INLINE cast21 #-}
+{-# INLINE cast22 #-}
+{-# INLINE cast23 #-}
+{-# INLINE cast24 #-}
+{-# INLINE cast25 #-}
+{-# INLINE cast26 #-}
+{-# INLINE cast27 #-}
+{-# INLINE cast28 #-}
+{-# INLINE cast29 #-}
+{-# INLINE cast30 #-}
+
+--------------------------------------------------------------------------------
+-- Cast functions with retryWithGC
+--------------------------------------------------------------------------------
+
+_cast0 :: (Castable a ca) => (IO ca) -> IO a
+_cast0 f = retryWithGC (f) >>= \ca -> uncast ca return
+
+_cast1 :: (Castable a ca, Castable y cy)
+        => (ca -> IO cy) -> a -> IO y
+_cast1 f a = 
+  cast a $ \ca ->
+    retryWithGC (f ca ) >>= \cy -> uncast cy return
+
+
+_cast2 :: (Castable a ca, Castable x1 cx1, Castable y cy)
+        => (ca -> cx1 -> IO cy) -> a -> x1 -> IO y
+_cast2 f a x1 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    retryWithGC (f ca cx1 ) >>= \cy -> uncast cy return
+
+
+_cast3 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable y cy)
+        => (ca -> cx1 -> cx2 -> IO cy) -> a -> x1 -> x2 -> IO y
+_cast3 f a x1 x2 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    retryWithGC (f ca cx1 cx2 ) >>= \cy -> uncast cy return
+
+
+_cast4 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> IO cy) -> a -> x1 -> x2 -> x3 -> IO y
+_cast4 f a x1 x2 x3 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    retryWithGC (f ca cx1 cx2 cx3 ) >>= \cy -> uncast cy return
+
+
+_cast5 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> IO y
+_cast5 f a x1 x2 x3 x4 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 ) >>= \cy -> uncast cy return
+
+
+_cast6 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> IO y
+_cast6 f a x1 x2 x3 x4 x5 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 ) >>= \cy -> uncast cy return
+
+
+_cast7 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> IO y
+_cast7 f a x1 x2 x3 x4 x5 x6 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 ) >>= \cy -> uncast cy return
+
+
+_cast8 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> IO y
+_cast8 f a x1 x2 x3 x4 x5 x6 x7 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 ) >>= \cy -> uncast cy return
+
+
+_cast9 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> IO y
+_cast9 f a x1 x2 x3 x4 x5 x6 x7 x8 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 ) >>= \cy -> uncast cy return
+
+
+_cast10 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> IO y
+_cast10 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 ) >>= \cy -> uncast cy return
+
+
+_cast11 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> IO y
+_cast11 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 ) >>= \cy -> uncast cy return
+
+
+_cast12 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> IO y
+_cast12 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 ) >>= \cy -> uncast cy return
+
+
+_cast13 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> IO y
+_cast13 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 ) >>= \cy -> uncast cy return
+
+
+_cast14 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> IO y
+_cast14 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 ) >>= \cy -> uncast cy return
+
+
+_cast15 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> IO y
+_cast15 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 ) >>= \cy -> uncast cy return
+
+
+_cast16 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> IO y
+_cast16 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 ) >>= \cy -> uncast cy return
+
+
+_cast17 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> IO y
+_cast17 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 ) >>= \cy -> uncast cy return
+
+
+_cast18 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> IO y
+_cast18 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 ) >>= \cy -> uncast cy return
+
+
+_cast19 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> IO y
+_cast19 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 ) >>= \cy -> uncast cy return
+
+
+_cast20 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> IO y
+_cast20 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 ) >>= \cy -> uncast cy return
+
+
+_cast21 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> IO y
+_cast21 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 ) >>= \cy -> uncast cy return
+
+
+_cast22 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> IO y
+_cast22 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 ) >>= \cy -> uncast cy return
+
+
+_cast23 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> IO y
+_cast23 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 ) >>= \cy -> uncast cy return
+
+
+_cast24 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> IO y
+_cast24 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 ) >>= \cy -> uncast cy return
+
+
+_cast25 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> IO y
+_cast25 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 ) >>= \cy -> uncast cy return
+
+
+_cast26 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> IO y
+_cast26 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 ) >>= \cy -> uncast cy return
+
+
+_cast27 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable x26 cx26, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> cx26 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> x26 -> IO y
+_cast27 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    cast x26 $ \cx26 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 cx26 ) >>= \cy -> uncast cy return
+
+
+_cast28 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable x26 cx26, Castable x27 cx27, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> cx26 -> cx27 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> x26 -> x27 -> IO y
+_cast28 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    cast x26 $ \cx26 ->
+    cast x27 $ \cx27 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 cx26 cx27 ) >>= \cy -> uncast cy return
+
+
+_cast29 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable x26 cx26, Castable x27 cx27, Castable x28 cx28, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> cx26 -> cx27 -> cx28 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> x26 -> x27 -> x28 -> IO y
+_cast29 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    cast x26 $ \cx26 ->
+    cast x27 $ \cx27 ->
+    cast x28 $ \cx28 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 cx26 cx27 cx28 ) >>= \cy -> uncast cy return
+
+_cast30 :: (Castable a ca, Castable x1 cx1, Castable x2 cx2, Castable x3 cx3, Castable x4 cx4, Castable x5 cx5, Castable x6 cx6, Castable x7 cx7, Castable x8 cx8, Castable x9 cx9, Castable x10 cx10, Castable x11 cx11, Castable x12 cx12, Castable x13 cx13, Castable x14 cx14, Castable x15 cx15, Castable x16 cx16, Castable x17 cx17, Castable x18 cx18, Castable x19 cx19, Castable x20 cx20, Castable x21 cx21, Castable x22 cx22, Castable x23 cx23, Castable x24 cx24, Castable x25 cx25, Castable x26 cx26, Castable x27 cx27, Castable x28 cx28, Castable x29 cx29, Castable y cy)
+        => (ca -> cx1 -> cx2 -> cx3 -> cx4 -> cx5 -> cx6 -> cx7 -> cx8 -> cx9 -> cx10 -> cx11 -> cx12 -> cx13 -> cx14 -> cx15 -> cx16 -> cx17 -> cx18 -> cx19 -> cx20 -> cx21 -> cx22 -> cx23 -> cx24 -> cx25 -> cx26 -> cx27 -> cx28 -> cx29 -> IO cy) -> a -> x1 -> x2 -> x3 -> x4 -> x5 -> x6 -> x7 -> x8 -> x9 -> x10 -> x11 -> x12 -> x13 -> x14 -> x15 -> x16 -> x17 -> x18 -> x19 -> x20 -> x21 -> x22 -> x23 -> x24 -> x25 -> x26 -> x27 -> x28 -> x29 -> IO y
+_cast30 f a x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 = 
+  cast a $ \ca ->
+    cast x1 $ \cx1 ->
+    cast x2 $ \cx2 ->
+    cast x3 $ \cx3 ->
+    cast x4 $ \cx4 ->
+    cast x5 $ \cx5 ->
+    cast x6 $ \cx6 ->
+    cast x7 $ \cx7 ->
+    cast x8 $ \cx8 ->
+    cast x9 $ \cx9 ->
+    cast x10 $ \cx10 ->
+    cast x11 $ \cx11 ->
+    cast x12 $ \cx12 ->
+    cast x13 $ \cx13 ->
+    cast x14 $ \cx14 ->
+    cast x15 $ \cx15 ->
+    cast x16 $ \cx16 ->
+    cast x17 $ \cx17 ->
+    cast x18 $ \cx18 ->
+    cast x19 $ \cx19 ->
+    cast x20 $ \cx20 ->
+    cast x21 $ \cx21 ->
+    cast x22 $ \cx22 ->
+    cast x23 $ \cx23 ->
+    cast x24 $ \cx24 ->
+    cast x25 $ \cx25 ->
+    cast x26 $ \cx26 ->
+    cast x27 $ \cx27 ->
+    cast x28 $ \cx28 ->
+    cast x29 $ \cx29 ->
+    retryWithGC (f ca cx1 cx2 cx3 cx4 cx5 cx6 cx7 cx8 cx9 cx10 cx11 cx12 cx13 cx14 cx15 cx16 cx17 cx18 cx19 cx20 cx21 cx22 cx23 cx24 cx25 cx26 cx27 cx28 cx29) >>= \cy -> uncast cy return
+
+
+{-# INLINE _cast0 #-}
+{-# INLINE _cast1 #-}
+{-# INLINE _cast2 #-}
+{-# INLINE _cast3 #-}
+{-# INLINE _cast4 #-}
+{-# INLINE _cast5 #-}
+{-# INLINE _cast6 #-}
+{-# INLINE _cast7 #-}
+{-# INLINE _cast8 #-}
+{-# INLINE _cast9 #-}
+{-# INLINE _cast10 #-}
+{-# INLINE _cast11 #-}
+{-# INLINE _cast12 #-}
+{-# INLINE _cast13 #-}
+{-# INLINE _cast14 #-}
+{-# INLINE _cast15 #-}
+{-# INLINE _cast16 #-}
+{-# INLINE _cast17 #-}
+{-# INLINE _cast18 #-}
+{-# INLINE _cast19 #-}
+{-# INLINE _cast20 #-}
+{-# INLINE _cast21 #-}
+{-# INLINE _cast22 #-}
+{-# INLINE _cast23 #-}
+{-# INLINE _cast24 #-}
+{-# INLINE _cast25 #-}
+{-# INLINE _cast26 #-}
+{-# INLINE _cast27 #-}
+{-# INLINE _cast28 #-}
+{-# INLINE _cast29 #-}
+{-# INLINE _cast30 #-}
diff --git a/src/Torch/Internal/Class.hs b/src/Torch/Internal/Class.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Class.hs
@@ -0,0 +1,82 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
+module Torch.Internal.Class where
+
+import Foreign (Ptr, ForeignPtr)
+
+class Castable a b where
+  cast   :: a -> (b -> IO r) -> IO r
+  uncast :: b -> (a -> IO r) -> IO r
+
+class CppObject a where
+  fromPtr :: Ptr a -> IO (ForeignPtr a)
+  deletePtr :: Ptr a -> IO ()
+
+class CppTuple2 m where
+  type A m
+  type B m
+  get0 :: m -> IO (A m)
+  get1 :: m -> IO (B m)
+  makeTuple2 :: (A m, B m) -> IO m
+  makeTuple2 = error "makeTuple2 is not implemented."
+  -- | Just an idea of default-signatures
+  -- default makeTuple2
+  --   :: forall a b c.
+  --    ( CppObject c
+  --    , ForeignPtr a ~ A m
+  --    , ForeignPtr b ~ B m
+  --    , ForeignPtr c ~ m
+  --    , Ptr a ~ A (Ptr c)
+  --    , Ptr b ~ B (Ptr c)
+  --    , CppTuple2 (Ptr c))
+  --   => (A m, B m)
+  --   -> IO m
+  -- makeTuple2 (a,b) =
+  --   withForeignPtr a $ \a' -> do
+  --     withForeignPtr b $ \b' -> do
+  --       fromPtr =<< makeTuple2 (a',b')
+
+class CppTuple2 m => CppTuple3 m where
+  type C m
+  get2 :: m -> IO (C m)
+  makeTuple3 :: (A m,B m,C m) -> IO m
+  makeTuple3 = error "makeTuple3 is not implemented."
+
+class CppTuple3 m => CppTuple4 m where
+  type D m
+  get3 :: m -> IO (D m)
+  makeTuple4 :: (A m,B m,C m,D m) -> IO m
+  makeTuple4 = error "makeTuple4 is not implemented."
+
+class CppTuple4 m => CppTuple5 m where
+  type E m
+  get4 :: m -> IO (E m)
+  makeTuple5 :: (A m,B m,C m,D m,E m) -> IO m
+  makeTuple5 = error "makeTuple5 is not implemented."
+
+class CppTuple5 m => CppTuple6 m where
+  type F m
+  get5 :: m -> IO (F m)
+  makeTuple6 :: (A m,B m,C m,D m,E m,F m) -> IO m
+  makeTuple6 = error "makeTuple6 is not implemented."
+
+class CppTuple6 m => CppTuple7 m where
+  type G m
+  get6 :: m -> IO (G m)
+  makeTuple7 :: (A m,B m,C m,D m,E m,F m,G m) -> IO m
+  makeTuple7 = error "makeTuple7 is not implemented."
+
+class CppTuple7 m => CppTuple8 m where
+  type H m
+  get7 :: m -> IO (H m)
+  makeTuple8 :: (A m,B m,C m,D m,E m,F m,G m,H m) -> IO m
+  makeTuple8 = error "makeTuple8 is not implemented."
+
+class CppTuple8 m => CppTuple9 m where
+  type I m
+  get8 :: m -> IO (I m)
+  makeTuple9 :: (A m,B m,C m,D m,E m,F m,G m,H m,I m) -> IO m
+  makeTuple9 = error "makeTuple9 is not implemented."
diff --git a/src/Torch/Internal/Const.hs b/src/Torch/Internal/Const.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Const.hs
@@ -0,0 +1,161 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Const where
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/ScalarType.h>"
+C.include "<ATen/core/Reduction.h>"
+C.include "<c10/core/Layout.h>"
+
+
+
+kByte :: ScalarType
+kByte = [C.pure| int8_t { (int8_t) at::ScalarType::Byte } |]
+
+kChar :: ScalarType
+kChar = [C.pure| int8_t { (int8_t) at::ScalarType::Char } |]
+
+kDouble :: ScalarType
+kDouble = [C.pure| int8_t { (int8_t) at::ScalarType::Double } |]
+
+kFloat :: ScalarType
+kFloat = [C.pure| int8_t { (int8_t) at::ScalarType::Float } |]
+
+kInt :: ScalarType
+kInt = [C.pure| int8_t { (int8_t) at::ScalarType::Int } |]
+
+kLong :: ScalarType
+kLong = [C.pure| int8_t { (int8_t) at::ScalarType::Long } |]
+
+kShort :: ScalarType
+kShort = [C.pure| int8_t { (int8_t) at::ScalarType::Short } |]
+
+kHalf :: ScalarType
+kHalf = [C.pure| int8_t { (int8_t) at::ScalarType::Half } |]
+
+kBool :: ScalarType
+kBool = [C.pure| int8_t { (int8_t) at::ScalarType::Bool } |]
+
+kComplexHalf :: ScalarType
+kComplexHalf = [C.pure| int8_t { (int8_t) at::ScalarType::ComplexHalf } |]
+
+kComplexFloat :: ScalarType
+kComplexFloat = [C.pure| int8_t { (int8_t) at::ScalarType::ComplexFloat } |]
+
+kComplexDouble :: ScalarType
+kComplexDouble = [C.pure| int8_t { (int8_t) at::ScalarType::ComplexDouble } |]
+
+kQInt8 :: ScalarType
+kQInt8 = [C.pure| int8_t { (int8_t) at::ScalarType::QInt8 } |]
+
+kQUInt8 :: ScalarType
+kQUInt8 = [C.pure| int8_t { (int8_t) at::ScalarType::QUInt8 } |]
+
+kQInt32 :: ScalarType
+kQInt32 = [C.pure| int8_t { (int8_t) at::ScalarType::QInt32 } |]
+
+kBFloat16 :: ScalarType
+kBFloat16 = [C.pure| int8_t { (int8_t) at::ScalarType::BFloat16 } |]
+
+kUndefined :: ScalarType
+kUndefined = [C.pure| int8_t { (int8_t) at::ScalarType::Undefined } |]
+
+kCPU :: DeviceType
+kCPU = [C.pure| int16_t { (int16_t) at::DeviceType::CPU } |]
+
+kCUDA :: DeviceType
+kCUDA = [C.pure| int16_t { (int16_t) at::DeviceType::CUDA } |]
+
+kMKLDNN :: DeviceType
+kMKLDNN = [C.pure| int16_t { (int16_t) at::DeviceType::MKLDNN } |]
+
+kOPENGL :: DeviceType
+kOPENGL = [C.pure| int16_t { (int16_t) at::DeviceType::OPENGL } |]
+
+kOPENCL :: DeviceType
+kOPENCL = [C.pure| int16_t { (int16_t) at::DeviceType::OPENCL } |]
+
+kIDEEP :: DeviceType
+kIDEEP = [C.pure| int16_t { (int16_t) at::DeviceType::IDEEP } |]
+
+kHIP :: DeviceType
+kHIP = [C.pure| int16_t { (int16_t) at::DeviceType::HIP } |]
+
+kFPGA :: DeviceType
+kFPGA = [C.pure| int16_t { (int16_t) at::DeviceType::FPGA } |]
+
+kXLA :: DeviceType
+kXLA = [C.pure| int16_t { (int16_t) at::DeviceType::XLA } |]
+
+kVulkan :: DeviceType
+kVulkan = [C.pure| int16_t { (int16_t) at::DeviceType::Vulkan } |]
+
+kMetal :: DeviceType
+kMetal = [C.pure| int16_t { (int16_t) at::DeviceType::Metal } |]
+
+kXPU :: DeviceType
+kXPU = [C.pure| int16_t { (int16_t) at::DeviceType::XPU } |]
+
+kCOMPILE_TIME_MAX_DEVICE_TYPES :: DeviceType
+kCOMPILE_TIME_MAX_DEVICE_TYPES = [C.pure| int16_t { (int16_t) at::DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES } |]
+
+-- TODO: add all values for at::Reduction
+
+kMean :: Int64
+kMean = [C.pure| int64_t { (int64_t) at::Reduction::Mean } |]
+
+bCPU :: Backend
+bCPU = [C.pure| int { (int) at::Backend::CPU } |]
+
+bCUDA :: Backend
+bCUDA = [C.pure| int { (int) at::Backend::CUDA } |]
+
+bHIP :: Backend
+bHIP = [C.pure| int { (int) at::Backend::HIP } |]
+
+bSparseCPU :: Backend
+bSparseCPU = [C.pure| int { (int) at::Backend::SparseCPU } |]
+
+bSparseCUDA :: Backend
+bSparseCUDA = [C.pure| int { (int) at::Backend::SparseCUDA } |]
+
+bSparseHIP :: Backend
+bSparseHIP = [C.pure| int { (int) at::Backend::SparseHIP } |]
+
+bXLA :: Backend
+bXLA = [C.pure| int { (int) at::Backend::XLA } |]
+
+bUndefined :: Backend
+bUndefined = [C.pure| int { (int) at::Backend::Undefined } |]
+
+bNumOptions :: Backend
+bNumOptions = [C.pure| int { (int) at::Backend::NumOptions } |]
+
+kStrided :: Layout
+kStrided = [C.pure| int8_t { (int8_t) at::kStrided } |]
+
+kSparse :: Layout
+kSparse = [C.pure| int8_t { (int8_t) at::kSparse } |]
+
+kMkldnn :: Layout
+kMkldnn = [C.pure| int8_t { (int8_t) at::kMkldnn } |]
diff --git a/src/Torch/Internal/GC.hs b/src/Torch/Internal/GC.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/GC.hs
@@ -0,0 +1,112 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+module Torch.Internal.GC where
+
+import Control.Concurrent (threadDelay)
+import Control.Concurrent.Async
+import Control.Exception.Safe (Exception, MonadThrow, Typeable, catch, throwIO, throwM)
+import Control.Monad (when)
+import Data.List (isPrefixOf)
+import Foreign.C.Types
+import GHC.ExecutionStack
+import Language.C.Inline.Cpp.Exceptions
+import System.Environment (lookupEnv)
+import System.IO (hPutStrLn, stderr)
+import System.IO.Unsafe (unsafePerformIO)
+import System.Mem (performGC)
+import System.SysInfo
+
+foreign import ccall unsafe "hasktorch_finalizer.h showWeakPtrList"
+  c_showWeakPtrList :: CInt -> IO ()
+
+-- malloc_trim is a glibc function. It doesn't exist on macos.
+#ifdef ENABLE_DUMMY_MALLOC_TRIM
+mallocTrim :: CInt -> IO ()
+mallocTrim _ = return ()
+#else
+foreign import ccall unsafe "malloc.h malloc_trim"
+  mallocTrim :: CInt -> IO ()
+#endif
+
+-- | Returns all objects of libtorch.
+-- Each time it is called, the age of the object increases by one.
+-- Dumps objects that are greater than or equal to the argument of age.
+dumpLibtorchObjects ::
+  -- | age
+  Int ->
+  -- | output
+  IO ()
+dumpLibtorchObjects age = c_showWeakPtrList (fromIntegral age)
+
+newtype HasktorchException = HasktorchException String
+  deriving (Show)
+
+instance Exception HasktorchException
+
+unsafeThrowableIO :: forall a m. MonadThrow m => IO a -> m a
+unsafeThrowableIO a = unsafePerformIO $ (pure <$> a) `catch` (\(CppStdException msg) -> pure . throwM $ HasktorchException msg)
+
+prettyException :: IO a -> IO a
+prettyException func =
+  func `catch` \a@(CppStdException message) -> do
+    flag <- lookupEnv "HASKTORCH_DEBUG"
+    when (flag /= Just "0") $ do
+      mst <- showStackTrace
+      case mst of
+        Just st -> hPutStrLn stderr st
+        Nothing -> hPutStrLn stderr "Cannot show stacktrace"
+      hPutStrLn stderr message
+    throwIO a
+{-# INLINE prettyException #-}
+
+retryWithGC' :: Int -> IO a -> IO a
+retryWithGC' count func =
+  func `catch` \a@(CppStdException message) ->
+    if isPrefixOf msgOutOfMemory message
+      then
+        if count <= 0
+          then throwIO $ userError $ "Too many calls to performGC, " ++ message
+          else do
+            performGC
+            mallocTrim 0
+            threadDelay 1000 -- We need delta delay(1ms) to wait GC.
+            retryWithGC' (count -1) func
+      else throwIO a
+  where
+    msgOutOfMemory :: String
+    msgOutOfMemory = "Exception: CUDA out of memory."
+{-# INLINE retryWithGC' #-}
+
+retryWithGC :: IO a -> IO a
+retryWithGC func = prettyException $ retryWithGC' 10 func
+{-# INLINE retryWithGC #-}
+
+checkOSMemoryWithGC :: IO ()
+checkOSMemoryWithGC = do
+  v <- sysInfo
+  case v of
+    Right stat -> do
+      let rate = (fromIntegral (freeram stat) / fromIntegral (totalram stat))
+      if rate <= 0.5
+        then do
+          performGC
+          mallocTrim 0
+        else return ()
+    Left _ -> return ()
+  threadDelay (500 * 1000) -- wait 500msec
+  checkOSMemoryWithGC
+
+monitorMemory :: IO () -> IO ()
+monitorMemory func = do
+  func `race` checkOSMemoryWithGC
+  return ()
diff --git a/src/Torch/Internal/Managed/Autograd.hs b/src/Torch/Internal/Managed/Autograd.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Autograd.hs
@@ -0,0 +1,22 @@
+
+module Torch.Internal.Managed.Autograd where
+
+import Foreign.ForeignPtr
+
+import qualified Torch.Internal.Unmanaged.Autograd as Unmanaged
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import Foreign.C.Types (CBool)
+
+
+grad :: ForeignPtr Tensor -> ForeignPtr TensorList -> IO (ForeignPtr TensorList)
+grad = _cast2 Unmanaged.grad
+
+
+makeIndependent :: ForeignPtr Tensor -> CBool -> IO (ForeignPtr Tensor)
+makeIndependent = _cast2 Unmanaged.makeIndependent
+
+dropVariable :: ForeignPtr Tensor -> IO (ForeignPtr Tensor)
+dropVariable = _cast1 Unmanaged.dropVariable
diff --git a/src/Torch/Internal/Managed/Cast.hs b/src/Torch/Internal/Managed/Cast.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Cast.hs
@@ -0,0 +1,143 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
+module Torch.Internal.Managed.Cast where
+
+import Control.Exception.Safe (throwIO)
+import Foreign.ForeignPtr
+import Foreign.C.Types
+import Data.Int
+import Control.Monad
+
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Type
+import Torch.Internal.Managed.Type.IntArray
+import Torch.Internal.Managed.Type.TensorList
+import Torch.Internal.Managed.Type.C10List
+import Torch.Internal.Managed.Type.IValueList
+import Torch.Internal.Managed.Type.C10Tuple
+import Torch.Internal.Managed.Type.C10Dict
+import Torch.Internal.Managed.Type.StdVector
+
+instance Castable Int (ForeignPtr IntArray) where
+  cast xs f = do
+    arr <- newIntArray
+    intArray_push_back_l arr $ fromIntegral xs
+    f arr
+  uncast xs f = do
+    v <- intArray_at_s xs 0
+    f (fromIntegral v)
+
+instance Castable [Int] (ForeignPtr IntArray) where
+  cast xs f = do
+    arr <- newIntArray
+    intArray_fromList arr (map fromIntegral xs)
+    f arr
+  uncast xs f = do
+    xs <- intArray_toList xs
+    f (map fromIntegral xs)
+
+instance Castable [Double] (ForeignPtr (StdVector CDouble)) where
+  cast xs f = do
+    arr <- newStdVectorDouble
+    forM_ xs $ (stdVectorDouble_push_back arr) . realToFrac
+    f arr
+  uncast xs f = do
+    len <- stdVectorDouble_size xs
+    -- NB: This check is necessary, because len is unsigned and it will wrap around if
+    --     we subtract 1 when it's 0.
+    if len == 0
+      then f []
+      else f =<< mapM (\i -> stdVectorDouble_at xs i >>= return . realToFrac) [0..(len - 1)]
+
+instance Castable [ForeignPtr Tensor] (ForeignPtr TensorList) where
+  cast xs f = do
+    l <- newTensorList
+    forM_ xs $ (tensorList_push_back_t l)
+    f l
+  uncast xs f = do
+    len <- tensorList_size xs
+    f =<< mapM (tensorList_at_s xs) [0..(len - 1)]
+
+instance Castable [ForeignPtr Tensor] (ForeignPtr (C10List Tensor)) where
+  cast xs f = do
+    l <- newC10ListTensor
+    forM_ xs $ (c10ListTensor_push_back l)
+    f l
+  uncast xs f = do
+    len <- c10ListTensor_size xs
+    f =<< mapM (c10ListTensor_at xs) [0..(len - 1)]
+
+instance Castable [ForeignPtr Tensor] (ForeignPtr (C10List (C10Optional Tensor))) where
+  cast xs f = do
+    l <- newC10ListOptionalTensor
+    forM_ xs $ (c10ListOptionalTensor_push_back l)
+    f l
+  uncast xs f = do
+    len <- c10ListOptionalTensor_size xs
+    f =<< mapM (c10ListOptionalTensor_at xs) [0..(len - 1)]
+
+instance Castable [CDouble] (ForeignPtr (C10List CDouble)) where
+  cast xs f = do
+    l <- newC10ListDouble
+    forM_ xs $ (c10ListDouble_push_back l)
+    f l
+  uncast xs f = do
+    len <- c10ListDouble_size xs
+    f =<< mapM (c10ListDouble_at xs) [0..(len - 1)]
+
+instance Castable [Int64] (ForeignPtr (C10List Int64)) where
+  cast xs f = do
+    l <- newC10ListInt
+    forM_ xs $ (c10ListInt_push_back l)
+    f l
+  uncast xs f = do
+    len <- c10ListInt_size xs
+    f =<< mapM (c10ListInt_at xs) [0..(len - 1)]
+
+instance Castable [CBool] (ForeignPtr (C10List CBool)) where
+  cast xs f = do
+    l <- newC10ListBool
+    forM_ xs $ (c10ListBool_push_back l)
+    f l
+  uncast xs f = do
+    len <- c10ListBool_size xs
+    f =<< mapM (c10ListBool_at xs) [0..(len - 1)]
+
+instance Castable [ForeignPtr IValue] (ForeignPtr IValueList) where
+  cast xs f = do
+    l <- newIValueList
+    forM_ xs $ (ivalueList_push_back l)
+    f l
+  uncast xs f = do
+    len <- ivalueList_size xs
+    f =<< mapM (ivalueList_at xs) [0..(len - 1)]
+
+instance Castable [ForeignPtr IValue] (ForeignPtr (C10Ptr IVTuple)) where
+  cast xs f = do
+    cast xs $ \ivalueList -> do
+      f =<< newC10Tuple_tuple ivalueList
+  uncast xs f = do
+    len <- c10Tuple_size xs
+    f =<< mapM (c10Tuple_at xs) [0..(len - 1)]
+
+instance Castable [ForeignPtr IValue] (ForeignPtr (C10List IValue)) where
+  cast [] _ = throwIO $ userError "[ForeignPtr IValue]'s length must be one or more."
+  cast xs f = do
+    l <- newC10ListIValue (head xs)
+    forM_ xs $ (c10ListIValue_push_back l)
+    f l
+  uncast xs f = do
+    len <- c10ListIValue_size xs
+    f =<< mapM (c10ListIValue_at xs) [0..(len - 1)]
+
+instance Castable [(ForeignPtr IValue,ForeignPtr IValue)] (ForeignPtr (C10Dict '(IValue,IValue))) where
+  cast [] _ = throwIO $ userError "[(ForeignPtr IValue,ForeignPtr IValue)]'s length must be one or more."
+  cast xs f = do
+    let (k,v) = (head xs)
+    l <- newC10Dict k v
+    forM_ xs $ \(k,v) -> (c10Dict_insert l k v)
+    f l
+  uncast xs f = f =<< c10Dict_toList xs
diff --git a/src/Torch/Internal/Managed/Native.hs b/src/Torch/Internal/Managed/Native.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native.hs
@@ -0,0 +1,37 @@
+
+module Torch.Internal.Managed.Native
+ ( module Torch.Internal.Managed.Native.Native0
+ , module Torch.Internal.Managed.Native.Native1
+ , module Torch.Internal.Managed.Native.Native2
+ , module Torch.Internal.Managed.Native.Native3
+ , module Torch.Internal.Managed.Native.Native4
+ , module Torch.Internal.Managed.Native.Native5
+ , module Torch.Internal.Managed.Native.Native6
+ , module Torch.Internal.Managed.Native.Native7
+ , module Torch.Internal.Managed.Native.Native8
+ , module Torch.Internal.Managed.Native.Native9
+ , module Torch.Internal.Managed.Native.Native10
+ , module Torch.Internal.Managed.Native.Native11
+ , module Torch.Internal.Managed.Native.Native12
+ , module Torch.Internal.Managed.Native.Native13
+ , module Torch.Internal.Managed.Native.Native14
+ , module Torch.Internal.Managed.Native.Native15
+ , module Torch.Internal.Managed.Native.Extra
+ ) where
+import Torch.Internal.Managed.Native.Native0
+import Torch.Internal.Managed.Native.Native1
+import Torch.Internal.Managed.Native.Native2
+import Torch.Internal.Managed.Native.Native3
+import Torch.Internal.Managed.Native.Native4
+import Torch.Internal.Managed.Native.Native5
+import Torch.Internal.Managed.Native.Native6
+import Torch.Internal.Managed.Native.Native7
+import Torch.Internal.Managed.Native.Native8
+import Torch.Internal.Managed.Native.Native9
+import Torch.Internal.Managed.Native.Native10
+import Torch.Internal.Managed.Native.Native11
+import Torch.Internal.Managed.Native.Native12
+import Torch.Internal.Managed.Native.Native13
+import Torch.Internal.Managed.Native.Native14
+import Torch.Internal.Managed.Native.Native15
+import Torch.Internal.Managed.Native.Extra
diff --git a/src/Torch/Internal/Managed/Native/Extra.hs b/src/Torch/Internal/Managed/Native/Extra.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Extra.hs
@@ -0,0 +1,38 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Extra where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Extra as Unmanaged
+
+
+ 
+max_values_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+max_values_tlb = _cast3 Unmanaged.max_values_tlb
+
+min_values_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+min_values_tlb = _cast3 Unmanaged.min_values_tlb
+
diff --git a/src/Torch/Internal/Managed/Native/Native0.hs b/src/Torch/Internal/Managed/Native/Native0.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native0.hs
@@ -0,0 +1,1973 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native0 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native0 as Unmanaged
+
+
+_cast_Byte_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cast_Byte_tb = _cast2 Unmanaged._cast_Byte_tb
+
+_cast_Byte_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cast_Byte_t = _cast1 Unmanaged._cast_Byte_t
+
+_cast_Char_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cast_Char_tb = _cast2 Unmanaged._cast_Char_tb
+
+_cast_Char_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cast_Char_t = _cast1 Unmanaged._cast_Char_t
+
+_cast_Double_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cast_Double_tb = _cast2 Unmanaged._cast_Double_tb
+
+_cast_Double_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cast_Double_t = _cast1 Unmanaged._cast_Double_t
+
+_cast_Float_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cast_Float_tb = _cast2 Unmanaged._cast_Float_tb
+
+_cast_Float_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cast_Float_t = _cast1 Unmanaged._cast_Float_t
+
+_cast_Int_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cast_Int_tb = _cast2 Unmanaged._cast_Int_tb
+
+_cast_Int_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cast_Int_t = _cast1 Unmanaged._cast_Int_t
+
+_cast_Long_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cast_Long_tb = _cast2 Unmanaged._cast_Long_tb
+
+_cast_Long_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cast_Long_t = _cast1 Unmanaged._cast_Long_t
+
+_cast_Short_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cast_Short_tb = _cast2 Unmanaged._cast_Short_tb
+
+_cast_Short_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cast_Short_t = _cast1 Unmanaged._cast_Short_t
+
+_cast_Half_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cast_Half_tb = _cast2 Unmanaged._cast_Half_tb
+
+_cast_Half_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cast_Half_t = _cast1 Unmanaged._cast_Half_t
+
+_make_dual_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_make_dual_ttl = _cast3 Unmanaged._make_dual_ttl
+
+_unpack_dual_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_unpack_dual_tl = _cast2 Unmanaged._unpack_dual_tl
+
+_new_zeros_with_same_feature_meta_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_new_zeros_with_same_feature_meta_ttl = _cast3 Unmanaged._new_zeros_with_same_feature_meta_ttl
+
+_new_zeros_with_same_feature_meta_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_new_zeros_with_same_feature_meta_tt = _cast2 Unmanaged._new_zeros_with_same_feature_meta_tt
+
+_has_same_storage_numel_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+_has_same_storage_numel_tt = _cast2 Unmanaged._has_same_storage_numel_tt
+
+align_tensors_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+align_tensors_l = _cast1 Unmanaged.align_tensors_l
+
+_assert_async_t
+  :: ForeignPtr Tensor
+  -> IO (())
+_assert_async_t = _cast1 Unmanaged._assert_async_t
+
+_assert_tensor_metadata_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ScalarType
+  -> IO (())
+_assert_tensor_metadata_tlls = _cast4 Unmanaged._assert_tensor_metadata_tlls
+
+_assert_tensor_metadata_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (())
+_assert_tensor_metadata_tll = _cast3 Unmanaged._assert_tensor_metadata_tll
+
+_assert_tensor_metadata_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+_assert_tensor_metadata_tl = _cast2 Unmanaged._assert_tensor_metadata_tl
+
+_assert_tensor_metadata_t
+  :: ForeignPtr Tensor
+  -> IO (())
+_assert_tensor_metadata_t = _cast1 Unmanaged._assert_tensor_metadata_t
+
+_use_cudnn_ctc_loss_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (CBool)
+_use_cudnn_ctc_loss_ttlll = _cast5 Unmanaged._use_cudnn_ctc_loss_ttlll
+
+_use_cudnn_ctc_loss_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (CBool)
+_use_cudnn_ctc_loss_ttttl = _cast5 Unmanaged._use_cudnn_ctc_loss_ttttl
+
+_cudnn_ctc_loss_ttlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_cudnn_ctc_loss_ttlllbb = _cast7 Unmanaged._cudnn_ctc_loss_ttlllbb
+
+_cudnn_ctc_loss_ttttlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_cudnn_ctc_loss_ttttlbb = _cast7 Unmanaged._cudnn_ctc_loss_ttttlbb
+
+_use_cudnn_rnn_flatten_weight
+  :: IO (CBool)
+_use_cudnn_rnn_flatten_weight = _cast0 Unmanaged._use_cudnn_rnn_flatten_weight
+
+_cudnn_rnn_flatten_weight_lllllllbb
+  :: ForeignPtr TensorList
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cudnn_rnn_flatten_weight_lllllllbb = _cast9 Unmanaged._cudnn_rnn_flatten_weight_lllllllbb
+
+_cudnn_rnn_tlltttllllbdbblt
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_cudnn_rnn_tlltttllllbdbblt = _cast16 Unmanaged._cudnn_rnn_tlltttllllbdbblt
+
+_cudnn_rnn_backward_tlltttttttllllbdbbltta
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,4))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList)))
+_cudnn_rnn_backward_tlltttttttllllbdbbltta = _cast22 Unmanaged._cudnn_rnn_backward_tlltttttttllllbdbbltta
+
+_cudnn_init_dropout_state_dblo
+  :: CDouble
+  -> CBool
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_cudnn_init_dropout_state_dblo = _cast4 Unmanaged._cudnn_init_dropout_state_dblo
+
+_debug_has_internal_overlap_t
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+_debug_has_internal_overlap_t = _cast1 Unmanaged._debug_has_internal_overlap_t
+
+_fused_dropout_tdG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_dropout_tdG = _cast3 Unmanaged._fused_dropout_tdG
+
+_fused_dropout_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_dropout_td = _cast2 Unmanaged._fused_dropout_td
+
+_masked_scale_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_masked_scale_ttd = _cast3 Unmanaged._masked_scale_ttd
+
+native_dropout_tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+native_dropout_tdb = _cast3 Unmanaged.native_dropout_tdb
+
+native_dropout_backward_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+native_dropout_backward_ttd = _cast3 Unmanaged.native_dropout_backward_ttd
+
+_sobol_engine_draw_tltlls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_sobol_engine_draw_tltlls = _cast6 Unmanaged._sobol_engine_draw_tltlls
+
+_sobol_engine_ff__tltll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_sobol_engine_ff__tltll = _cast5 Unmanaged._sobol_engine_ff__tltll
+
+_sobol_engine_scramble__ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_sobol_engine_scramble__ttl = _cast3 Unmanaged._sobol_engine_scramble__ttl
+
+_sobol_engine_initialize_state__tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_sobol_engine_initialize_state__tl = _cast2 Unmanaged._sobol_engine_initialize_state__tl
+
+_reshape_from_tensor_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_reshape_from_tensor_tt = _cast2 Unmanaged._reshape_from_tensor_tt
+
+_shape_as_tensor_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_shape_as_tensor_t = _cast1 Unmanaged._shape_as_tensor_t
+
+dropout_tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+dropout_tdb = _cast3 Unmanaged.dropout_tdb
+
+dropout__tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+dropout__tdb = _cast3 Unmanaged.dropout__tdb
+
+feature_dropout_tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+feature_dropout_tdb = _cast3 Unmanaged.feature_dropout_tdb
+
+feature_dropout__tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+feature_dropout__tdb = _cast3 Unmanaged.feature_dropout__tdb
+
+alpha_dropout_tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+alpha_dropout_tdb = _cast3 Unmanaged.alpha_dropout_tdb
+
+alpha_dropout__tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+alpha_dropout__tdb = _cast3 Unmanaged.alpha_dropout__tdb
+
+feature_alpha_dropout_tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+feature_alpha_dropout_tdb = _cast3 Unmanaged.feature_alpha_dropout_tdb
+
+feature_alpha_dropout__tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+feature_alpha_dropout__tdb = _cast3 Unmanaged.feature_alpha_dropout__tdb
+
+abs_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+abs_t = _cast1 Unmanaged.abs_t
+
+abs__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+abs__t = _cast1 Unmanaged.abs__t
+
+abs_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+abs_out_tt = _cast2 Unmanaged.abs_out_tt
+
+absolute_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+absolute_t = _cast1 Unmanaged.absolute_t
+
+absolute_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+absolute_out_tt = _cast2 Unmanaged.absolute_out_tt
+
+angle_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+angle_t = _cast1 Unmanaged.angle_t
+
+angle_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+angle_out_tt = _cast2 Unmanaged.angle_out_tt
+
+view_as_real_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+view_as_real_t = _cast1 Unmanaged.view_as_real_t
+
+view_as_complex_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+view_as_complex_t = _cast1 Unmanaged.view_as_complex_t
+
+sgn_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sgn_t = _cast1 Unmanaged.sgn_t
+
+sgn_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sgn_out_tt = _cast2 Unmanaged.sgn_out_tt
+
+real_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+real_t = _cast1 Unmanaged.real_t
+
+imag_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+imag_t = _cast1 Unmanaged.imag_t
+
+_conj_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_conj_t = _cast1 Unmanaged._conj_t
+
+conj_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conj_t = _cast1 Unmanaged.conj_t
+
+_conj_physical_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_conj_physical_t = _cast1 Unmanaged._conj_physical_t
+
+conj_physical_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conj_physical_t = _cast1 Unmanaged.conj_physical_t
+
+conj_physical_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conj_physical_out_tt = _cast2 Unmanaged.conj_physical_out_tt
+
+conj_physical__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conj_physical__t = _cast1 Unmanaged.conj_physical__t
+
+resolve_conj_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+resolve_conj_t = _cast1 Unmanaged.resolve_conj_t
+
+resolve_neg_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+resolve_neg_t = _cast1 Unmanaged.resolve_neg_t
+
+_neg_view_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_neg_view_t = _cast1 Unmanaged._neg_view_t
+
+acos_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+acos_t = _cast1 Unmanaged.acos_t
+
+acos__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+acos__t = _cast1 Unmanaged.acos__t
+
+acos_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+acos_out_tt = _cast2 Unmanaged.acos_out_tt
+
+arccos_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arccos_t = _cast1 Unmanaged.arccos_t
+
+arccos__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arccos__t = _cast1 Unmanaged.arccos__t
+
+arccos_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arccos_out_tt = _cast2 Unmanaged.arccos_out_tt
+
+avg_pool1d_tlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool1d_tlllbb = _cast6 Unmanaged.avg_pool1d_tlllbb
+
+avg_pool1d_tlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool1d_tlllb = _cast5 Unmanaged.avg_pool1d_tlllb
+
+avg_pool1d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool1d_tlll = _cast4 Unmanaged.avg_pool1d_tlll
+
+avg_pool1d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool1d_tll = _cast3 Unmanaged.avg_pool1d_tll
+
+avg_pool1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool1d_tl = _cast2 Unmanaged.avg_pool1d_tl
+
+adaptive_avg_pool1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+adaptive_avg_pool1d_tl = _cast2 Unmanaged.adaptive_avg_pool1d_tl
+
+adaptive_max_pool1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool1d_tl = _cast2 Unmanaged.adaptive_max_pool1d_tl
+
+add_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+add_tts = _cast3 Unmanaged.add_tts
+
+add_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+add_tt = _cast2 Unmanaged.add_tt
+
+add_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+add_out_ttts = _cast4 Unmanaged.add_out_ttts
+
+add_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+add_out_ttt = _cast3 Unmanaged.add_out_ttt
+
+_add_relu_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu_tts = _cast3 Unmanaged._add_relu_tts
+
+_add_relu_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_add_relu_tt = _cast2 Unmanaged._add_relu_tt
+
+_add_relu__tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu__tts = _cast3 Unmanaged._add_relu__tts
+
+_add_relu__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_add_relu__tt = _cast2 Unmanaged._add_relu__tt
+
+_add_relu_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu_out_ttts = _cast4 Unmanaged._add_relu_out_ttts
+
+_add_relu_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_add_relu_out_ttt = _cast3 Unmanaged._add_relu_out_ttt
+
+_add_relu_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu_tss = _cast3 Unmanaged._add_relu_tss
+
+_add_relu_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu_ts = _cast2 Unmanaged._add_relu_ts
+
+_add_relu__tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu__tss = _cast3 Unmanaged._add_relu__tss
+
+_add_relu__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu__ts = _cast2 Unmanaged._add_relu__ts
+
+add_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+add_tss = _cast3 Unmanaged.add_tss
+
+add_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+add_ts = _cast2 Unmanaged.add_ts
+
+addmv_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmv_tttss = _cast5 Unmanaged.addmv_tttss
+
+addmv_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmv_ttts = _cast4 Unmanaged.addmv_ttts
+
+addmv_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addmv_ttt = _cast3 Unmanaged.addmv_ttt
+
+addmv__tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmv__tttss = _cast5 Unmanaged.addmv__tttss
+
+addmv__ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmv__ttts = _cast4 Unmanaged.addmv__ttts
+
+addmv__ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addmv__ttt = _cast3 Unmanaged.addmv__ttt
+
+addmv_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmv_out_ttttss = _cast6 Unmanaged.addmv_out_ttttss
+
+addmv_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmv_out_tttts = _cast5 Unmanaged.addmv_out_tttts
+
+addmv_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addmv_out_tttt = _cast4 Unmanaged.addmv_out_tttt
+
+addr_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addr_tttss = _cast5 Unmanaged.addr_tttss
+
+addr_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addr_ttts = _cast4 Unmanaged.addr_ttts
+
+addr_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addr_ttt = _cast3 Unmanaged.addr_ttt
+
+addr_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addr_out_ttttss = _cast6 Unmanaged.addr_out_ttttss
+
+addr_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addr_out_tttts = _cast5 Unmanaged.addr_out_tttts
+
+addr_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addr_out_tttt = _cast4 Unmanaged.addr_out_tttt
+
+affine_grid_generator_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+affine_grid_generator_tlb = _cast3 Unmanaged.affine_grid_generator_tlb
+
+affine_grid_generator_backward_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+affine_grid_generator_backward_tlb = _cast3 Unmanaged.affine_grid_generator_backward_tlb
+
+_is_all_true_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_is_all_true_t = _cast1 Unmanaged._is_all_true_t
+
+_is_any_true_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_is_any_true_t = _cast1 Unmanaged._is_any_true_t
+
+_test_check_tensor_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_check_tensor_t = _cast1 Unmanaged._test_check_tensor_t
+
+all_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+all_tlb = _cast3 Unmanaged.all_tlb
+
+all_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+all_tl = _cast2 Unmanaged.all_tl
+
+all_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+all_out_ttlb = _cast4 Unmanaged.all_out_ttlb
+
+all_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+all_out_ttl = _cast3 Unmanaged.all_out_ttl
+
+all_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+all_tnb = _cast3 Unmanaged.all_tnb
+
+all_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+all_tn = _cast2 Unmanaged.all_tn
+
+all_out_ttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+all_out_ttnb = _cast4 Unmanaged.all_out_ttnb
+
+all_out_ttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+all_out_ttn = _cast3 Unmanaged.all_out_ttn
+
+allclose_ttddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (CBool)
+allclose_ttddb = _cast5 Unmanaged.allclose_ttddb
+
+allclose_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (CBool)
+allclose_ttdd = _cast4 Unmanaged.allclose_ttdd
+
+allclose_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (CBool)
+allclose_ttd = _cast3 Unmanaged.allclose_ttd
+
+allclose_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+allclose_tt = _cast2 Unmanaged.allclose_tt
+
+any_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+any_tlb = _cast3 Unmanaged.any_tlb
+
+any_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+any_tl = _cast2 Unmanaged.any_tl
+
+any_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+any_out_ttlb = _cast4 Unmanaged.any_out_ttlb
+
+any_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+any_out_ttl = _cast3 Unmanaged.any_out_ttl
+
+any_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+any_tnb = _cast3 Unmanaged.any_tnb
+
+any_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+any_tn = _cast2 Unmanaged.any_tn
+
+any_out_ttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+any_out_ttnb = _cast4 Unmanaged.any_out_ttnb
+
+any_out_ttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+any_out_ttn = _cast3 Unmanaged.any_out_ttn
+
+arange_so
+  :: ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+arange_so = _cast2 Unmanaged.arange_so
+
+arange_s
+  :: ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+arange_s = _cast1 Unmanaged.arange_s
+
+arange_sso
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+arange_sso = _cast3 Unmanaged.arange_sso
+
+arange_ss
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+arange_ss = _cast2 Unmanaged.arange_ss
+
+arange_ssso
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+arange_ssso = _cast4 Unmanaged.arange_ssso
+
+arange_sss
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+arange_sss = _cast3 Unmanaged.arange_sss
+
+arange_out_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+arange_out_ts = _cast2 Unmanaged.arange_out_ts
+
+arange_out_tsss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+arange_out_tsss = _cast4 Unmanaged.arange_out_tsss
+
+-- arange_out_tss
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr Scalar
+--   -> ForeignPtr Scalar
+--   -> IO (ForeignPtr Tensor)
+-- arange_out_tss = _cast3 Unmanaged.arange_out_tss
+
+_dim_arange_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_dim_arange_tl = _cast2 Unmanaged._dim_arange_tl
+
+argmax_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argmax_tlb = _cast3 Unmanaged.argmax_tlb
+
+argmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+argmax_tl = _cast2 Unmanaged.argmax_tl
+
+argmax_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+argmax_t = _cast1 Unmanaged.argmax_t
+
+argmax_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argmax_out_ttlb = _cast4 Unmanaged.argmax_out_ttlb
+
+argmax_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+argmax_out_ttl = _cast3 Unmanaged.argmax_out_ttl
+
+argmax_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+argmax_out_tt = _cast2 Unmanaged.argmax_out_tt
+
+argmin_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argmin_tlb = _cast3 Unmanaged.argmin_tlb
+
+argmin_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+argmin_tl = _cast2 Unmanaged.argmin_tl
+
+argmin_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+argmin_t = _cast1 Unmanaged.argmin_t
+
+argmin_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argmin_out_ttlb = _cast4 Unmanaged.argmin_out_ttlb
+
+argmin_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+argmin_out_ttl = _cast3 Unmanaged.argmin_out_ttl
+
+argmin_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+argmin_out_tt = _cast2 Unmanaged.argmin_out_tt
+
+acosh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+acosh_t = _cast1 Unmanaged.acosh_t
+
+acosh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+acosh__t = _cast1 Unmanaged.acosh__t
+
+acosh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+acosh_out_tt = _cast2 Unmanaged.acosh_out_tt
+
+arccosh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arccosh_t = _cast1 Unmanaged.arccosh_t
+
+arccosh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arccosh__t = _cast1 Unmanaged.arccosh__t
+
+arccosh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arccosh_out_tt = _cast2 Unmanaged.arccosh_out_tt
+
+asinh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+asinh_t = _cast1 Unmanaged.asinh_t
+
+asinh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+asinh__t = _cast1 Unmanaged.asinh__t
+
+asinh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+asinh_out_tt = _cast2 Unmanaged.asinh_out_tt
+
+arcsinh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arcsinh_t = _cast1 Unmanaged.arcsinh_t
+
+arcsinh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arcsinh__t = _cast1 Unmanaged.arcsinh__t
+
+arcsinh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arcsinh_out_tt = _cast2 Unmanaged.arcsinh_out_tt
+
+atanh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atanh_t = _cast1 Unmanaged.atanh_t
+
+atanh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atanh__t = _cast1 Unmanaged.atanh__t
+
+atanh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atanh_out_tt = _cast2 Unmanaged.atanh_out_tt
+
+arctanh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arctanh_t = _cast1 Unmanaged.arctanh_t
+
+arctanh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arctanh__t = _cast1 Unmanaged.arctanh__t
+
+arctanh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arctanh_out_tt = _cast2 Unmanaged.arctanh_out_tt
+
+as_strided_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+as_strided_tlll = _cast4 Unmanaged.as_strided_tlll
+
+as_strided_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+as_strided_tll = _cast3 Unmanaged.as_strided_tll
+
+as_strided__tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+as_strided__tlll = _cast4 Unmanaged.as_strided__tlll
+
+as_strided__tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+as_strided__tll = _cast3 Unmanaged.as_strided__tll
+
+asin_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+asin_t = _cast1 Unmanaged.asin_t
+
+asin__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+asin__t = _cast1 Unmanaged.asin__t
+
+asin_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+asin_out_tt = _cast2 Unmanaged.asin_out_tt
+
+arcsin_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arcsin_t = _cast1 Unmanaged.arcsin_t
+
+arcsin__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arcsin__t = _cast1 Unmanaged.arcsin__t
+
+arcsin_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arcsin_out_tt = _cast2 Unmanaged.arcsin_out_tt
+
+atan_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atan_t = _cast1 Unmanaged.atan_t
+
+atan__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atan__t = _cast1 Unmanaged.atan__t
+
+atan_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atan_out_tt = _cast2 Unmanaged.atan_out_tt
+
+arctan_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arctan_t = _cast1 Unmanaged.arctan_t
+
+arctan__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arctan__t = _cast1 Unmanaged.arctan__t
+
+arctan_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arctan_out_tt = _cast2 Unmanaged.arctan_out_tt
+
+atleast_1d_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atleast_1d_t = _cast1 Unmanaged.atleast_1d_t
+
+atleast_1d_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+atleast_1d_l = _cast1 Unmanaged.atleast_1d_l
+
+atleast_2d_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atleast_2d_t = _cast1 Unmanaged.atleast_2d_t
+
+atleast_2d_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+atleast_2d_l = _cast1 Unmanaged.atleast_2d_l
+
+atleast_3d_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atleast_3d_t = _cast1 Unmanaged.atleast_3d_t
+
+atleast_3d_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+atleast_3d_l = _cast1 Unmanaged.atleast_3d_l
+
+baddbmm_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+baddbmm_tttss = _cast5 Unmanaged.baddbmm_tttss
+
+baddbmm_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+baddbmm_ttts = _cast4 Unmanaged.baddbmm_ttts
+
+baddbmm_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+baddbmm_ttt = _cast3 Unmanaged.baddbmm_ttt
+
+baddbmm_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+baddbmm_out_ttttss = _cast6 Unmanaged.baddbmm_out_ttttss
+
+baddbmm_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+baddbmm_out_tttts = _cast5 Unmanaged.baddbmm_out_tttts
+
+baddbmm_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+baddbmm_out_tttt = _cast4 Unmanaged.baddbmm_out_tttt
+
+bartlett_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+bartlett_window_lo = _cast2 Unmanaged.bartlett_window_lo
+
+bartlett_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+bartlett_window_l = _cast1 Unmanaged.bartlett_window_l
+
+bartlett_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+bartlett_window_lbo = _cast3 Unmanaged.bartlett_window_lbo
+
+bartlett_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bartlett_window_lb = _cast2 Unmanaged.bartlett_window_lb
+
+batch_norm_tttttbddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> 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
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)))
+_batch_norm_impl_index_tttttbddb = _cast9 Unmanaged._batch_norm_impl_index_tttttbddb
+
+_batch_norm_impl_index_backward_ltttttttbdat
+  :: Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_batch_norm_impl_index_backward_ltttttttbdat = _cast12 Unmanaged._batch_norm_impl_index_backward_ltttttttbdat
+
+bernoulli_tG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+bernoulli_tG = _cast2 Unmanaged.bernoulli_tG
+
+bernoulli_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bernoulli_t = _cast1 Unmanaged.bernoulli_t
+
+bernoulli_out_ttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+bernoulli_out_ttG = _cast3 Unmanaged.bernoulli_out_ttG
+
+-- bernoulli_out_tt
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr Tensor
+--   -> IO (ForeignPtr Tensor)
+-- bernoulli_out_tt = _cast2 Unmanaged.bernoulli_out_tt
+
+bernoulli_tdG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+bernoulli_tdG = _cast3 Unmanaged.bernoulli_tdG
+
+bernoulli_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+bernoulli_td = _cast2 Unmanaged.bernoulli_td
+
+bilinear_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bilinear_tttt = _cast4 Unmanaged.bilinear_tttt
+
+bilinear_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bilinear_ttt = _cast3 Unmanaged.bilinear_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_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
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_with_logits_ttttl = _cast5 Unmanaged.binary_cross_entropy_with_logits_ttttl
+
+binary_cross_entropy_with_logits_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_with_logits_tttt = _cast4 Unmanaged.binary_cross_entropy_with_logits_tttt
+
+binary_cross_entropy_with_logits_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_with_logits_ttt = _cast3 Unmanaged.binary_cross_entropy_with_logits_ttt
+
+binary_cross_entropy_with_logits_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_with_logits_tt = _cast2 Unmanaged.binary_cross_entropy_with_logits_tt
+
+bincount_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+bincount_ttl = _cast3 Unmanaged.bincount_ttl
+
+bincount_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bincount_tt = _cast2 Unmanaged.bincount_tt
+
+bincount_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bincount_t = _cast1 Unmanaged.bincount_t
+
+bitwise_not_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_not_t = _cast1 Unmanaged.bitwise_not_t
+
+bitwise_not_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_not_out_tt = _cast2 Unmanaged.bitwise_not_out_tt
+
+copysign_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+copysign_out_ttt = _cast3 Unmanaged.copysign_out_ttt
+
+copysign_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+copysign_tt = _cast2 Unmanaged.copysign_tt
+
+copysign_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+copysign_ts = _cast2 Unmanaged.copysign_ts
+
+copysign_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+copysign_out_tts = _cast3 Unmanaged.copysign_out_tts
+
+logical_not_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logical_not_t = _cast1 Unmanaged.logical_not_t
+
+logical_not_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logical_not_out_tt = _cast2 Unmanaged.logical_not_out_tt
+
+logical_xor_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logical_xor_tt = _cast2 Unmanaged.logical_xor_tt
+
+logical_xor_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> 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
+  -> IO (ForeignPtr Tensor)
+blackman_window_lo = _cast2 Unmanaged.blackman_window_lo
+
+blackman_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+blackman_window_l = _cast1 Unmanaged.blackman_window_l
+
+blackman_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+blackman_window_lbo = _cast3 Unmanaged.blackman_window_lbo
+
+blackman_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+blackman_window_lb = _cast2 Unmanaged.blackman_window_lb
+
+bmm_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bmm_tt = _cast2 Unmanaged.bmm_tt
+
+bmm_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bmm_out_ttt = _cast3 Unmanaged.bmm_out_ttt
+
+broadcast_tensors_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+broadcast_tensors_l = _cast1 Unmanaged.broadcast_tensors_l
+
+broadcast_to_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+broadcast_to_tl = _cast2 Unmanaged.broadcast_to_tl
+
+_sparse_broadcast_to_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_broadcast_to_tl = _cast2 Unmanaged._sparse_broadcast_to_tl
+
+cat_ll
+  :: ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cat_ll = _cast2 Unmanaged.cat_ll
+
+cat_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+cat_l = _cast1 Unmanaged.cat_l
+
+cat_out_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cat_out_tll = _cast3 Unmanaged.cat_out_tll
+
+cat_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+cat_out_tl = _cast2 Unmanaged.cat_out_tl
+
+cat_ln
+  :: ForeignPtr TensorList
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+cat_ln = _cast2 Unmanaged.cat_ln
+
+cat_out_tln
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+cat_out_tln = _cast3 Unmanaged.cat_out_tln
+
+concat_ll
+  :: ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+concat_ll = _cast2 Unmanaged.concat_ll
+
+concat_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+concat_l = _cast1 Unmanaged.concat_l
+
+concat_out_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+concat_out_tll = _cast3 Unmanaged.concat_out_tll
+
+concat_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+concat_out_tl = _cast2 Unmanaged.concat_out_tl
+
+concat_ln
+  :: ForeignPtr TensorList
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+concat_ln = _cast2 Unmanaged.concat_ln
+
+concat_out_tln
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+concat_out_tln = _cast3 Unmanaged.concat_out_tln
+
+concatenate_ll
+  :: ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+concatenate_ll = _cast2 Unmanaged.concatenate_ll
+
+concatenate_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+concatenate_l = _cast1 Unmanaged.concatenate_l
+
+concatenate_out_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+concatenate_out_tll = _cast3 Unmanaged.concatenate_out_tll
+
+concatenate_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+concatenate_out_tl = _cast2 Unmanaged.concatenate_out_tl
+
+concatenate_ln
+  :: ForeignPtr TensorList
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+concatenate_ln = _cast2 Unmanaged.concatenate_ln
+
+concatenate_out_tln
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+concatenate_out_tln = _cast3 Unmanaged.concatenate_out_tln
+
diff --git a/src/Torch/Internal/Managed/Native/Native1.hs b/src/Torch/Internal/Managed/Native/Native1.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native1.hs
@@ -0,0 +1,2053 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native1 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native1 as Unmanaged
+
+
+block_diag_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+block_diag_l = _cast1 Unmanaged.block_diag_l
+
+ceil_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ceil_t = _cast1 Unmanaged.ceil_t
+
+ceil__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ceil__t = _cast1 Unmanaged.ceil__t
+
+ceil_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ceil_out_tt = _cast2 Unmanaged.ceil_out_tt
+
+chain_matmul_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+chain_matmul_l = _cast1 Unmanaged.chain_matmul_l
+
+chain_matmul_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+chain_matmul_out_tl = _cast2 Unmanaged.chain_matmul_out_tl
+
+unsafe_chunk_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+unsafe_chunk_tll = _cast3 Unmanaged.unsafe_chunk_tll
+
+unsafe_chunk_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+unsafe_chunk_tl = _cast2 Unmanaged.unsafe_chunk_tl
+
+chunk_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+chunk_tll = _cast3 Unmanaged.chunk_tll
+
+chunk_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+chunk_tl = _cast2 Unmanaged.chunk_tl
+
+tensor_split_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_split_tll = _cast3 Unmanaged.tensor_split_tll
+
+tensor_split_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_split_tl = _cast2 Unmanaged.tensor_split_tl
+
+tensor_split_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_split_ttl = _cast3 Unmanaged.tensor_split_ttl
+
+tensor_split_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+tensor_split_tt = _cast2 Unmanaged.tensor_split_tt
+
+clamp_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_tss = _cast3 Unmanaged.clamp_tss
+
+clamp_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_ts = _cast2 Unmanaged.clamp_ts
+
+clamp_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_t = _cast1 Unmanaged.clamp_t
+
+clamp_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_ttt = _cast3 Unmanaged.clamp_ttt
+
+clamp_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_tt = _cast2 Unmanaged.clamp_tt
+
+clamp__tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp__tss = _cast3 Unmanaged.clamp__tss
+
+clamp__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp__ts = _cast2 Unmanaged.clamp__ts
+
+clamp__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp__t = _cast1 Unmanaged.clamp__t
+
+clamp__ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp__ttt = _cast3 Unmanaged.clamp__ttt
+
+clamp__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp__tt = _cast2 Unmanaged.clamp__tt
+
+clamp_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_out_ttss = _cast4 Unmanaged.clamp_out_ttss
+
+clamp_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_out_tts = _cast3 Unmanaged.clamp_out_tts
+
+clamp_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_out_tt = _cast2 Unmanaged.clamp_out_tt
+
+clamp_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_out_tttt = _cast4 Unmanaged.clamp_out_tttt
+
+clamp_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_out_ttt = _cast3 Unmanaged.clamp_out_ttt
+
+clamp_max_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_max_ts = _cast2 Unmanaged.clamp_max_ts
+
+clamp_max_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_max_tt = _cast2 Unmanaged.clamp_max_tt
+
+clamp_max__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_max__ts = _cast2 Unmanaged.clamp_max__ts
+
+clamp_max__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_max__tt = _cast2 Unmanaged.clamp_max__tt
+
+clamp_max_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_max_out_tts = _cast3 Unmanaged.clamp_max_out_tts
+
+clamp_max_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_max_out_ttt = _cast3 Unmanaged.clamp_max_out_ttt
+
+clamp_min_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_min_ts = _cast2 Unmanaged.clamp_min_ts
+
+clamp_min_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_min_tt = _cast2 Unmanaged.clamp_min_tt
+
+clamp_min__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_min__ts = _cast2 Unmanaged.clamp_min__ts
+
+clamp_min__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_min__tt = _cast2 Unmanaged.clamp_min__tt
+
+clamp_min_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clamp_min_out_tts = _cast3 Unmanaged.clamp_min_out_tts
+
+clamp_min_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clamp_min_out_ttt = _cast3 Unmanaged.clamp_min_out_ttt
+
+clip_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clip_tss = _cast3 Unmanaged.clip_tss
+
+clip_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clip_ts = _cast2 Unmanaged.clip_ts
+
+clip_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip_t = _cast1 Unmanaged.clip_t
+
+clip_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip_ttt = _cast3 Unmanaged.clip_ttt
+
+clip_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip_tt = _cast2 Unmanaged.clip_tt
+
+clip__tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clip__tss = _cast3 Unmanaged.clip__tss
+
+clip__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clip__ts = _cast2 Unmanaged.clip__ts
+
+clip__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip__t = _cast1 Unmanaged.clip__t
+
+clip__ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip__ttt = _cast3 Unmanaged.clip__ttt
+
+clip__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip__tt = _cast2 Unmanaged.clip__tt
+
+clip_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clip_out_ttss = _cast4 Unmanaged.clip_out_ttss
+
+clip_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+clip_out_tts = _cast3 Unmanaged.clip_out_tts
+
+clip_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip_out_tt = _cast2 Unmanaged.clip_out_tt
+
+clip_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip_out_tttt = _cast4 Unmanaged.clip_out_tttt
+
+clip_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clip_out_ttt = _cast3 Unmanaged.clip_out_ttt
+
+cudnn_is_acceptable_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+cudnn_is_acceptable_t = _cast1 Unmanaged.cudnn_is_acceptable_t
+
+complex_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+complex_tt = _cast2 Unmanaged.complex_tt
+
+complex_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+complex_out_ttt = _cast3 Unmanaged.complex_out_ttt
+
+polar_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+polar_tt = _cast2 Unmanaged.polar_tt
+
+polar_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+polar_out_ttt = _cast3 Unmanaged.polar_out_ttt
+
+constant_pad_nd_tls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+constant_pad_nd_tls = _cast3 Unmanaged.constant_pad_nd_tls
+
+constant_pad_nd_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+constant_pad_nd_tl = _cast2 Unmanaged.constant_pad_nd_tl
+
+convolution_tttlllbll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+convolution_tttlllbll = _cast9 Unmanaged.convolution_tttlllbll
+
+convolution_backward_tttllllblla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+convolution_backward_tttllllblla = _cast11 Unmanaged.convolution_backward_tttllllblla
+
+convolution_overrideable_tttlllbll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+convolution_overrideable_tttlllbll = _cast9 Unmanaged.convolution_overrideable_tttlllbll
+
+convolution_backward_overrideable_tttlllblla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+convolution_backward_overrideable_tttlllblla = _cast10 Unmanaged.convolution_backward_overrideable_tttlllblla
+
+_convolution_tttlllbllbbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convolution_tttlllbllbbbb = _cast13 Unmanaged._convolution_tttlllbllbbbb
+
+_convolution_tttlllbllbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convolution_tttlllbllbbb = _cast12 Unmanaged._convolution_tttlllbllbbb
+
+_convolution_mode_tttlsll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_convolution_mode_tttlsll = _cast7 Unmanaged._convolution_mode_tttlsll
+
+_convolution_double_backward_ttttttlllblla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_convolution_double_backward_ttttttlllblla = _cast13 Unmanaged._convolution_double_backward_ttttttlllblla
+
+conv1d_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv1d_tttllll = _cast7 Unmanaged.conv1d_tttllll
+
+conv1d_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv1d_tttlll = _cast6 Unmanaged.conv1d_tttlll
+
+conv1d_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv1d_tttll = _cast5 Unmanaged.conv1d_tttll
+
+conv1d_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv1d_tttl = _cast4 Unmanaged.conv1d_tttl
+
+conv1d_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv1d_ttt = _cast3 Unmanaged.conv1d_ttt
+
+conv1d_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv1d_tt = _cast2 Unmanaged.conv1d_tt
+
+conv2d_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv2d_tttllll = _cast7 Unmanaged.conv2d_tttllll
+
+conv2d_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv2d_tttlll = _cast6 Unmanaged.conv2d_tttlll
+
+conv2d_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv2d_tttll = _cast5 Unmanaged.conv2d_tttll
+
+conv2d_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv2d_tttl = _cast4 Unmanaged.conv2d_tttl
+
+conv2d_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv2d_ttt = _cast3 Unmanaged.conv2d_ttt
+
+conv2d_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv2d_tt = _cast2 Unmanaged.conv2d_tt
+
+conv3d_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv3d_tttllll = _cast7 Unmanaged.conv3d_tttllll
+
+conv3d_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv3d_tttlll = _cast6 Unmanaged.conv3d_tttlll
+
+conv3d_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv3d_tttll = _cast5 Unmanaged.conv3d_tttll
+
+conv3d_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv3d_tttl = _cast4 Unmanaged.conv3d_tttl
+
+conv3d_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv3d_ttt = _cast3 Unmanaged.conv3d_ttt
+
+conv3d_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv3d_tt = _cast2 Unmanaged.conv3d_tt
+
+conv1d_tttlsll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv1d_tttlsll = _cast7 Unmanaged.conv1d_tttlsll
+
+conv1d_tttlsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv1d_tttlsl = _cast6 Unmanaged.conv1d_tttlsl
+
+conv1d_tttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+conv1d_tttls = _cast5 Unmanaged.conv1d_tttls
+
+conv2d_tttlsll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv2d_tttlsll = _cast7 Unmanaged.conv2d_tttlsll
+
+conv2d_tttlsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv2d_tttlsl = _cast6 Unmanaged.conv2d_tttlsl
+
+conv2d_tttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+conv2d_tttls = _cast5 Unmanaged.conv2d_tttls
+
+conv3d_tttlsll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv3d_tttlsll = _cast7 Unmanaged.conv3d_tttlsll
+
+conv3d_tttlsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv3d_tttlsl = _cast6 Unmanaged.conv3d_tttlsl
+
+conv3d_tttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+conv3d_tttls = _cast5 Unmanaged.conv3d_tttls
+
+conv_tbc_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv_tbc_tttl = _cast4 Unmanaged.conv_tbc_tttl
+
+conv_tbc_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv_tbc_ttt = _cast3 Unmanaged.conv_tbc_ttt
+
+conv_tbc_backward_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+conv_tbc_backward_ttttl = _cast5 Unmanaged.conv_tbc_backward_ttttl
+
+conv_transpose1d_tttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose1d_tttlllll = _cast8 Unmanaged.conv_transpose1d_tttlllll
+
+conv_transpose1d_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv_transpose1d_tttllll = _cast7 Unmanaged.conv_transpose1d_tttllll
+
+conv_transpose1d_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose1d_tttlll = _cast6 Unmanaged.conv_transpose1d_tttlll
+
+conv_transpose1d_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose1d_tttll = _cast5 Unmanaged.conv_transpose1d_tttll
+
+conv_transpose1d_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose1d_tttl = _cast4 Unmanaged.conv_transpose1d_tttl
+
+conv_transpose1d_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv_transpose1d_ttt = _cast3 Unmanaged.conv_transpose1d_ttt
+
+conv_transpose1d_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv_transpose1d_tt = _cast2 Unmanaged.conv_transpose1d_tt
+
+conv_transpose2d_tttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose2d_tttlllll = _cast8 Unmanaged.conv_transpose2d_tttlllll
+
+conv_transpose2d_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv_transpose2d_tttllll = _cast7 Unmanaged.conv_transpose2d_tttllll
+
+conv_transpose2d_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose2d_tttlll = _cast6 Unmanaged.conv_transpose2d_tttlll
+
+conv_transpose2d_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose2d_tttll = _cast5 Unmanaged.conv_transpose2d_tttll
+
+conv_transpose2d_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose2d_tttl = _cast4 Unmanaged.conv_transpose2d_tttl
+
+conv_transpose2d_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv_transpose2d_ttt = _cast3 Unmanaged.conv_transpose2d_ttt
+
+conv_transpose2d_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv_transpose2d_tt = _cast2 Unmanaged.conv_transpose2d_tt
+
+conv_transpose3d_tttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose3d_tttlllll = _cast8 Unmanaged.conv_transpose3d_tttlllll
+
+conv_transpose3d_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv_transpose3d_tttllll = _cast7 Unmanaged.conv_transpose3d_tttllll
+
+conv_transpose3d_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose3d_tttlll = _cast6 Unmanaged.conv_transpose3d_tttlll
+
+conv_transpose3d_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose3d_tttll = _cast5 Unmanaged.conv_transpose3d_tttll
+
+conv_transpose3d_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_transpose3d_tttl = _cast4 Unmanaged.conv_transpose3d_tttl
+
+conv_transpose3d_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv_transpose3d_ttt = _cast3 Unmanaged.conv_transpose3d_ttt
+
+conv_transpose3d_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv_transpose3d_tt = _cast2 Unmanaged.conv_transpose3d_tt
+
+copy_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+copy_ttb = _cast3 Unmanaged.copy_ttb
+
+copy_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+copy_tt = _cast2 Unmanaged.copy_tt
+
+_copy_from_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_copy_from_ttb = _cast3 Unmanaged._copy_from_ttb
+
+_copy_from_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_copy_from_tt = _cast2 Unmanaged._copy_from_tt
+
+_copy_from_and_resize_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_copy_from_and_resize_tt = _cast2 Unmanaged._copy_from_and_resize_tt
+
+cos_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cos_t = _cast1 Unmanaged.cos_t
+
+cos__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cos__t = _cast1 Unmanaged.cos__t
+
+cos_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cos_out_tt = _cast2 Unmanaged.cos_out_tt
+
+cosh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cosh_t = _cast1 Unmanaged.cosh_t
+
+cosh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cosh__t = _cast1 Unmanaged.cosh__t
+
+cosh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cosh_out_tt = _cast2 Unmanaged.cosh_out_tt
+
+cosine_embedding_loss_tttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cosine_embedding_loss_tttdl = _cast5 Unmanaged.cosine_embedding_loss_tttdl
+
+cosine_embedding_loss_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+cosine_embedding_loss_tttd = _cast4 Unmanaged.cosine_embedding_loss_tttd
+
+cosine_embedding_loss_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cosine_embedding_loss_ttt = _cast3 Unmanaged.cosine_embedding_loss_ttt
+
+count_nonzero_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+count_nonzero_tl = _cast2 Unmanaged.count_nonzero_tl
+
+count_nonzero_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+count_nonzero_t = _cast1 Unmanaged.count_nonzero_t
+
+cov_tltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cov_tltt = _cast4 Unmanaged.cov_tltt
+
+cov_tlt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cov_tlt = _cast3 Unmanaged.cov_tlt
+
+cov_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cov_tl = _cast2 Unmanaged.cov_tl
+
+cov_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cov_t = _cast1 Unmanaged.cov_t
+
+corrcoef_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+corrcoef_t = _cast1 Unmanaged.corrcoef_t
+
+cudnn_affine_grid_generator_tllll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cudnn_affine_grid_generator_tllll = _cast5 Unmanaged.cudnn_affine_grid_generator_tllll
+
+cudnn_affine_grid_generator_backward_tllll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cudnn_affine_grid_generator_backward_tllll = _cast5 Unmanaged.cudnn_affine_grid_generator_backward_tllll
+
+cudnn_batch_norm_tttttbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+cudnn_batch_norm_tttttbdd = _cast8 Unmanaged.cudnn_batch_norm_tttttbdd
+
+cudnn_batch_norm_backward_tttttttdt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+cudnn_batch_norm_backward_tttttttdt = _cast9 Unmanaged.cudnn_batch_norm_backward_tttttttdt
+
+cudnn_convolution_ttllllbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_ttllllbbb = _cast9 Unmanaged.cudnn_convolution_ttllllbbb
+
+cudnn_convolution_transpose_ttlllllbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_transpose_ttlllllbbb = _cast10 Unmanaged.cudnn_convolution_transpose_ttlllllbbb
+
+_mps_convolution_transpose_ttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_mps_convolution_transpose_ttlllll = _cast7 Unmanaged._mps_convolution_transpose_ttlllll
+
+mps_convolution_transpose_backward_tttllllla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mps_convolution_transpose_backward_tttllllla = _cast9 Unmanaged.mps_convolution_transpose_backward_tttllllla
+
+cudnn_convolution_relu_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_relu_tttllll = _cast7 Unmanaged.cudnn_convolution_relu_tttllll
+
+cudnn_convolution_add_relu_tttstllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_add_relu_tttstllll = _cast9 Unmanaged.cudnn_convolution_add_relu_tttstllll
+
+cudnn_grid_sampler_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cudnn_grid_sampler_tt = _cast2 Unmanaged.cudnn_grid_sampler_tt
+
+cudnn_grid_sampler_backward_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cudnn_grid_sampler_backward_ttt = _cast3 Unmanaged.cudnn_grid_sampler_backward_ttt
+
+cummax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummax_tl = _cast2 Unmanaged.cummax_tl
+
+cummax_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummax_out_tttl = _cast4 Unmanaged.cummax_out_tttl
+
+cummax_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummax_tn = _cast2 Unmanaged.cummax_tn
+
+cummax_out_tttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummax_out_tttn = _cast4 Unmanaged.cummax_out_tttn
+
+_cummax_helper_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (())
+_cummax_helper_tttl = _cast4 Unmanaged._cummax_helper_tttl
+
+cummin_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummin_tl = _cast2 Unmanaged.cummin_tl
+
+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 (StdTuple '(Tensor,Tensor)))
+cummin_tn = _cast2 Unmanaged.cummin_tn
+
+cummin_out_tttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cummin_out_tttn = _cast4 Unmanaged.cummin_out_tttn
+
+_cummin_helper_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (())
+_cummin_helper_tttl = _cast4 Unmanaged._cummin_helper_tttl
+
+cummaxmin_backward_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cummaxmin_backward_tttl = _cast4 Unmanaged.cummaxmin_backward_tttl
+
+cumprod_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+cumprod_tls = _cast3 Unmanaged.cumprod_tls
+
+cumprod_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cumprod_tl = _cast2 Unmanaged.cumprod_tl
+
+cumprod_out_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+cumprod_out_ttls = _cast4 Unmanaged.cumprod_out_ttls
+
+cumprod_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cumprod_out_ttl = _cast3 Unmanaged.cumprod_out_ttl
+
+cumprod_tns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+cumprod_tns = _cast3 Unmanaged.cumprod_tns
+
+cumprod_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+cumprod_tn = _cast2 Unmanaged.cumprod_tn
+
+cumprod_out_ttns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+cumprod_out_ttns = _cast4 Unmanaged.cumprod_out_ttns
+
+cumprod_out_ttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+cumprod_out_ttn = _cast3 Unmanaged.cumprod_out_ttn
+
+cumprod_backward_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cumprod_backward_ttlt = _cast4 Unmanaged.cumprod_backward_ttlt
+
+cumsum_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+cumsum_tls = _cast3 Unmanaged.cumsum_tls
+
+cumsum_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cumsum_tl = _cast2 Unmanaged.cumsum_tl
+
+cumsum_out_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+cumsum_out_ttls = _cast4 Unmanaged.cumsum_out_ttls
+
+cumsum_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+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
+
+cumulative_trapezoid_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cumulative_trapezoid_ttl = _cast3 Unmanaged.cumulative_trapezoid_ttl
+
+cumulative_trapezoid_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cumulative_trapezoid_tt = _cast2 Unmanaged.cumulative_trapezoid_tt
+
+cumulative_trapezoid_tsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cumulative_trapezoid_tsl = _cast3 Unmanaged.cumulative_trapezoid_tsl
+
+cumulative_trapezoid_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+cumulative_trapezoid_ts = _cast2 Unmanaged.cumulative_trapezoid_ts
+
+cumulative_trapezoid_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cumulative_trapezoid_t = _cast1 Unmanaged.cumulative_trapezoid_t
+
+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
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+ctc_loss_ttttllb = _cast7 Unmanaged.ctc_loss_ttttllb
+
+ctc_loss_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+ctc_loss_ttttll = _cast6 Unmanaged.ctc_loss_ttttll
+
+ctc_loss_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+ctc_loss_ttttl = _cast5 Unmanaged.ctc_loss_ttttl
+
+ctc_loss_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ctc_loss_tttt = _cast4 Unmanaged.ctc_loss_tttt
+
+_ctc_loss_ttlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttlllb = _cast6 Unmanaged._ctc_loss_ttlllb
+
+_ctc_loss_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttlll = _cast5 Unmanaged._ctc_loss_ttlll
+
+_ctc_loss_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttll = _cast4 Unmanaged._ctc_loss_ttll
+
+_ctc_loss_ttttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttttlb = _cast6 Unmanaged._ctc_loss_ttttlb
+
+_ctc_loss_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttttl = _cast5 Unmanaged._ctc_loss_ttttl
+
+_ctc_loss_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_tttt = _cast4 Unmanaged._ctc_loss_tttt
+
+_ctc_loss_backward_tttllttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_ctc_loss_backward_tttllttlb = _cast9 Unmanaged._ctc_loss_backward_tttllttlb
+
+_ctc_loss_backward_tttllttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_ctc_loss_backward_tttllttl = _cast8 Unmanaged._ctc_loss_backward_tttllttl
+
+_ctc_loss_backward_tttttttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_ctc_loss_backward_tttttttlb = _cast9 Unmanaged._ctc_loss_backward_tttttttlb
+
+_ctc_loss_backward_tttttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_ctc_loss_backward_tttttttl = _cast8 Unmanaged._ctc_loss_backward_tttttttl
+
+diag_embed_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diag_embed_tlll = _cast4 Unmanaged.diag_embed_tlll
+
+diag_embed_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diag_embed_tll = _cast3 Unmanaged.diag_embed_tll
+
+diag_embed_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diag_embed_tl = _cast2 Unmanaged.diag_embed_tl
+
+diag_embed_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diag_embed_t = _cast1 Unmanaged.diag_embed_t
+
+diagflat_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagflat_tl = _cast2 Unmanaged.diagflat_tl
+
+diagflat_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diagflat_t = _cast1 Unmanaged.diagflat_t
+
+diagonal_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_tlll = _cast4 Unmanaged.diagonal_tlll
+
+diagonal_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_tll = _cast3 Unmanaged.diagonal_tll
+
+diagonal_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_tl = _cast2 Unmanaged.diagonal_tl
+
+diagonal_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diagonal_t = _cast1 Unmanaged.diagonal_t
+
+linalg_diagonal_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_diagonal_tlll = _cast4 Unmanaged.linalg_diagonal_tlll
+
+linalg_diagonal_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_diagonal_tll = _cast3 Unmanaged.linalg_diagonal_tll
+
+linalg_diagonal_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_diagonal_tl = _cast2 Unmanaged.linalg_diagonal_tl
+
+linalg_diagonal_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_diagonal_t = _cast1 Unmanaged.linalg_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
+
+diagonal_backward_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_backward_tllll = _cast5 Unmanaged.diagonal_backward_tllll
+
+diff_tlltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diff_tlltt = _cast5 Unmanaged.diff_tlltt
+
+diff_tllt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diff_tllt = _cast4 Unmanaged.diff_tllt
+
+diff_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diff_tll = _cast3 Unmanaged.diff_tll
+
+diff_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diff_tl = _cast2 Unmanaged.diff_tl
+
+diff_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diff_t = _cast1 Unmanaged.diff_t
+
+diff_out_ttlltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diff_out_ttlltt = _cast6 Unmanaged.diff_out_ttlltt
+
+diff_out_ttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diff_out_ttllt = _cast5 Unmanaged.diff_out_ttllt
+
+diff_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diff_out_ttll = _cast4 Unmanaged.diff_out_ttll
+
+diff_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diff_out_ttl = _cast3 Unmanaged.diff_out_ttl
+
+diff_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diff_out_tt = _cast2 Unmanaged.diff_out_tt
+
+gradient_tsll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+gradient_tsll = _cast4 Unmanaged.gradient_tsll
+
+gradient_tsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+gradient_tsl = _cast3 Unmanaged.gradient_tsl
+
+gradient_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+gradient_t = _cast1 Unmanaged.gradient_t
+
+gradient_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+gradient_tll = _cast3 Unmanaged.gradient_tll
+
+gradient_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr TensorList)
+gradient_tl = _cast2 Unmanaged.gradient_tl
+
+gradient_tA
+  :: ForeignPtr Tensor
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+gradient_tA = _cast2 Unmanaged.gradient_tA
+
+div_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+div_tt = _cast2 Unmanaged.div_tt
+
+div_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+div_out_ttt = _cast3 Unmanaged.div_out_ttt
+
+div_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+div_tts = _cast3 Unmanaged.div_tts
+
+div_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+div_out_ttts = _cast4 Unmanaged.div_out_ttts
+
+div_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+div_ts = _cast2 Unmanaged.div_ts
+
+div_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+div_tss = _cast3 Unmanaged.div_tss
+
+divide_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+divide_tt = _cast2 Unmanaged.divide_tt
+
+divide_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+divide_out_ttt = _cast3 Unmanaged.divide_out_ttt
+
+divide_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+divide_ts = _cast2 Unmanaged.divide_ts
+
+divide_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+divide_tts = _cast3 Unmanaged.divide_tts
+
+divide_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+divide_out_ttts = _cast4 Unmanaged.divide_out_ttts
+
+divide_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+divide_tss = _cast3 Unmanaged.divide_tss
+
+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
+
+dot_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+dot_tt = _cast2 Unmanaged.dot_tt
+
+dot_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+dot_out_ttt = _cast3 Unmanaged.dot_out_ttt
+
+vdot_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+vdot_tt = _cast2 Unmanaged.vdot_tt
+
+vdot_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+vdot_out_ttt = _cast3 Unmanaged.vdot_out_ttt
+
+einsum_sll
+  :: ForeignPtr StdString
+  -> ForeignPtr TensorList
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+einsum_sll = _cast3 Unmanaged.einsum_sll
+
+einsum_sl
+  :: ForeignPtr StdString
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+einsum_sl = _cast2 Unmanaged.einsum_sl
+
+embedding_ttlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+embedding_ttlbb = _cast5 Unmanaged.embedding_ttlbb
+
+embedding_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+embedding_ttlb = _cast4 Unmanaged.embedding_ttlb
+
diff --git a/src/Torch/Internal/Managed/Native/Native10.hs b/src/Torch/Internal/Managed/Native/Native10.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native10.hs
@@ -0,0 +1,2232 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native10 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native10 as Unmanaged
+
+
+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_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_backward_tllb = _cast4 Unmanaged.upsample_bicubic2d_backward_tllb
+
+_upsample_bicubic2d_aa_out_ttlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_out_ttlbdd = _cast6 Unmanaged._upsample_bicubic2d_aa_out_ttlbdd
+
+_upsample_bicubic2d_aa_out_ttlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_out_ttlbd = _cast5 Unmanaged._upsample_bicubic2d_aa_out_ttlbd
+
+_upsample_bicubic2d_aa_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_out_ttlb = _cast4 Unmanaged._upsample_bicubic2d_aa_out_ttlb
+
+_upsample_bicubic2d_aa_tlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_tlbdd = _cast5 Unmanaged._upsample_bicubic2d_aa_tlbdd
+
+-- _upsample_bicubic2d_aa_tlbd
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr IntArray
+--   -> CBool
+--   -> CDouble
+--   -> IO (ForeignPtr Tensor)
+-- _upsample_bicubic2d_aa_tlbd = _cast4 Unmanaged._upsample_bicubic2d_aa_tlbd
+
+_upsample_bicubic2d_aa_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_tlb = _cast3 Unmanaged._upsample_bicubic2d_aa_tlb
+
+_upsample_bicubic2d_aa_backward_out_ttllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_backward_out_ttllbdd = _cast7 Unmanaged._upsample_bicubic2d_aa_backward_out_ttllbdd
+
+_upsample_bicubic2d_aa_backward_out_ttllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_backward_out_ttllbd = _cast6 Unmanaged._upsample_bicubic2d_aa_backward_out_ttllbd
+
+_upsample_bicubic2d_aa_backward_out_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_backward_out_ttllb = _cast5 Unmanaged._upsample_bicubic2d_aa_backward_out_ttllb
+
+_upsample_bicubic2d_aa_backward_tllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_backward_tllbdd = _cast6 Unmanaged._upsample_bicubic2d_aa_backward_tllbdd
+
+_upsample_bicubic2d_aa_backward_tllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_backward_tllbd = _cast5 Unmanaged._upsample_bicubic2d_aa_backward_tllbd
+
+_upsample_bicubic2d_aa_backward_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_backward_tllb = _cast4 Unmanaged._upsample_bicubic2d_aa_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
+  -> ForeignPtr IntArray
+  -> CBool
+  -> 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_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> 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
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> 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_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> 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
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_out_ttl = _cast3 Unmanaged.upsample_nearest1d_out_ttl
+
+_upsample_nearest_exact1d_out_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact1d_out_ttld = _cast4 Unmanaged._upsample_nearest_exact1d_out_ttld
+
+_upsample_nearest_exact1d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact1d_out_ttl = _cast3 Unmanaged._upsample_nearest_exact1d_out_ttl
+
+upsample_nearest1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_tl = _cast2 Unmanaged.upsample_nearest1d_tl
+
+-- _upsample_nearest_exact1d_tld
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr IntArray
+--   -> CDouble
+--   -> IO (ForeignPtr Tensor)
+-- _upsample_nearest_exact1d_tld = _cast3 Unmanaged._upsample_nearest_exact1d_tld
+
+_upsample_nearest_exact1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact1d_tl = _cast2 Unmanaged._upsample_nearest_exact1d_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
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_backward_out_ttll = _cast4 Unmanaged.upsample_nearest1d_backward_out_ttll
+
+_upsample_nearest_exact1d_backward_out_ttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact1d_backward_out_ttlld = _cast5 Unmanaged._upsample_nearest_exact1d_backward_out_ttlld
+
+_upsample_nearest_exact1d_backward_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact1d_backward_out_ttll = _cast4 Unmanaged._upsample_nearest_exact1d_backward_out_ttll
+
+upsample_nearest1d_backward_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_backward_tll = _cast3 Unmanaged.upsample_nearest1d_backward_tll
+
+_upsample_nearest_exact1d_backward_tlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact1d_backward_tlld = _cast4 Unmanaged._upsample_nearest_exact1d_backward_tlld
+
+_upsample_nearest_exact1d_backward_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact1d_backward_tll = _cast3 Unmanaged._upsample_nearest_exact1d_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
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_out_ttl = _cast3 Unmanaged.upsample_nearest2d_out_ttl
+
+_upsample_nearest_exact2d_out_ttldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_out_ttldd = _cast5 Unmanaged._upsample_nearest_exact2d_out_ttldd
+
+_upsample_nearest_exact2d_out_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_out_ttld = _cast4 Unmanaged._upsample_nearest_exact2d_out_ttld
+
+_upsample_nearest_exact2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_out_ttl = _cast3 Unmanaged._upsample_nearest_exact2d_out_ttl
+
+upsample_nearest2d_tldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_tldd = _cast4 Unmanaged.upsample_nearest2d_tldd
+
+upsample_nearest2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_tl = _cast2 Unmanaged.upsample_nearest2d_tl
+
+_upsample_nearest_exact2d_tldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_tldd = _cast4 Unmanaged._upsample_nearest_exact2d_tldd
+
+-- _upsample_nearest_exact2d_tld
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr IntArray
+--   -> CDouble
+--   -> IO (ForeignPtr Tensor)
+-- _upsample_nearest_exact2d_tld = _cast3 Unmanaged._upsample_nearest_exact2d_tld
+
+_upsample_nearest_exact2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_tl = _cast2 Unmanaged._upsample_nearest_exact2d_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
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_backward_out_ttll = _cast4 Unmanaged.upsample_nearest2d_backward_out_ttll
+
+_upsample_nearest_exact2d_backward_out_ttlldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_backward_out_ttlldd = _cast6 Unmanaged._upsample_nearest_exact2d_backward_out_ttlldd
+
+_upsample_nearest_exact2d_backward_out_ttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_backward_out_ttlld = _cast5 Unmanaged._upsample_nearest_exact2d_backward_out_ttlld
+
+_upsample_nearest_exact2d_backward_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_backward_out_ttll = _cast4 Unmanaged._upsample_nearest_exact2d_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_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_backward_tll = _cast3 Unmanaged.upsample_nearest2d_backward_tll
+
+_upsample_nearest_exact2d_backward_tlldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_backward_tlldd = _cast5 Unmanaged._upsample_nearest_exact2d_backward_tlldd
+
+_upsample_nearest_exact2d_backward_tlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_backward_tlld = _cast4 Unmanaged._upsample_nearest_exact2d_backward_tlld
+
+_upsample_nearest_exact2d_backward_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_backward_tll = _cast3 Unmanaged._upsample_nearest_exact2d_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
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_out_ttl = _cast3 Unmanaged.upsample_nearest3d_out_ttl
+
+_upsample_nearest_exact3d_out_ttlddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_out_ttlddd = _cast6 Unmanaged._upsample_nearest_exact3d_out_ttlddd
+
+_upsample_nearest_exact3d_out_ttldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_out_ttldd = _cast5 Unmanaged._upsample_nearest_exact3d_out_ttldd
+
+_upsample_nearest_exact3d_out_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_out_ttld = _cast4 Unmanaged._upsample_nearest_exact3d_out_ttld
+
+_upsample_nearest_exact3d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_out_ttl = _cast3 Unmanaged._upsample_nearest_exact3d_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_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_tl = _cast2 Unmanaged.upsample_nearest3d_tl
+
+_upsample_nearest_exact3d_tlddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_tlddd = _cast5 Unmanaged._upsample_nearest_exact3d_tlddd
+
+_upsample_nearest_exact3d_tldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_tldd = _cast4 Unmanaged._upsample_nearest_exact3d_tldd
+
+-- _upsample_nearest_exact3d_tld
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr IntArray
+--   -> CDouble
+--   -> IO (ForeignPtr Tensor)
+-- _upsample_nearest_exact3d_tld = _cast3 Unmanaged._upsample_nearest_exact3d_tld
+
+_upsample_nearest_exact3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_tl = _cast2 Unmanaged._upsample_nearest_exact3d_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
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_backward_out_ttll = _cast4 Unmanaged.upsample_nearest3d_backward_out_ttll
+
+_upsample_nearest_exact3d_backward_out_ttllddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_backward_out_ttllddd = _cast7 Unmanaged._upsample_nearest_exact3d_backward_out_ttllddd
+
+_upsample_nearest_exact3d_backward_out_ttlldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_backward_out_ttlldd = _cast6 Unmanaged._upsample_nearest_exact3d_backward_out_ttlldd
+
+_upsample_nearest_exact3d_backward_out_ttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_backward_out_ttlld = _cast5 Unmanaged._upsample_nearest_exact3d_backward_out_ttlld
+
+_upsample_nearest_exact3d_backward_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_backward_out_ttll = _cast4 Unmanaged._upsample_nearest_exact3d_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_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_backward_tll = _cast3 Unmanaged.upsample_nearest3d_backward_tll
+
+_upsample_nearest_exact3d_backward_tllddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_backward_tllddd = _cast6 Unmanaged._upsample_nearest_exact3d_backward_tllddd
+
+_upsample_nearest_exact3d_backward_tlldd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_backward_tlldd = _cast5 Unmanaged._upsample_nearest_exact3d_backward_tlldd
+
+_upsample_nearest_exact3d_backward_tlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_backward_tlld = _cast4 Unmanaged._upsample_nearest_exact3d_backward_tlld
+
+_upsample_nearest_exact3d_backward_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_backward_tll = _cast3 Unmanaged._upsample_nearest_exact3d_backward_tll
+
+sigmoid_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sigmoid_backward_out_ttt = _cast3 Unmanaged.sigmoid_backward_out_ttt
+
+sigmoid_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sigmoid_backward_tt = _cast2 Unmanaged.sigmoid_backward_tt
+
+logit_backward_out_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+logit_backward_out_tttd = _cast4 Unmanaged.logit_backward_out_tttd
+
+logit_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logit_backward_out_ttt = _cast3 Unmanaged.logit_backward_out_ttt
+
+logit_backward_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+logit_backward_ttd = _cast3 Unmanaged.logit_backward_ttd
+
+logit_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logit_backward_tt = _cast2 Unmanaged.logit_backward_tt
+
+tanh_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tanh_backward_out_ttt = _cast3 Unmanaged.tanh_backward_out_ttt
+
+tanh_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tanh_backward_tt = _cast2 Unmanaged.tanh_backward_tt
+
+slow_conv_transpose2d_out_tttltllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_out_tttltllll = _cast9 Unmanaged.slow_conv_transpose2d_out_tttltllll
+
+slow_conv_transpose2d_out_tttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_out_tttltlll = _cast8 Unmanaged.slow_conv_transpose2d_out_tttltlll
+
+slow_conv_transpose2d_out_tttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_out_tttltll = _cast7 Unmanaged.slow_conv_transpose2d_out_tttltll
+
+slow_conv_transpose2d_out_tttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_out_tttltl = _cast6 Unmanaged.slow_conv_transpose2d_out_tttltl
+
+slow_conv_transpose2d_out_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_out_tttlt = _cast5 Unmanaged.slow_conv_transpose2d_out_tttlt
+
+slow_conv_transpose2d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_out_tttl = _cast4 Unmanaged.slow_conv_transpose2d_out_tttl
+
+slow_conv_transpose2d_ttltllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_ttltllll = _cast8 Unmanaged.slow_conv_transpose2d_ttltllll
+
+slow_conv_transpose2d_ttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_ttltlll = _cast7 Unmanaged.slow_conv_transpose2d_ttltlll
+
+slow_conv_transpose2d_ttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_ttltll = _cast6 Unmanaged.slow_conv_transpose2d_ttltll
+
+slow_conv_transpose2d_ttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_ttltl = _cast5 Unmanaged.slow_conv_transpose2d_ttltl
+
+slow_conv_transpose2d_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_ttlt = _cast4 Unmanaged.slow_conv_transpose2d_ttlt
+
+slow_conv_transpose2d_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose2d_ttl = _cast3 Unmanaged.slow_conv_transpose2d_ttl
+
+slow_conv_transpose3d_out_tttltllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_out_tttltllll = _cast9 Unmanaged.slow_conv_transpose3d_out_tttltllll
+
+slow_conv_transpose3d_out_tttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_out_tttltlll = _cast8 Unmanaged.slow_conv_transpose3d_out_tttltlll
+
+slow_conv_transpose3d_out_tttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_out_tttltll = _cast7 Unmanaged.slow_conv_transpose3d_out_tttltll
+
+slow_conv_transpose3d_out_tttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_out_tttltl = _cast6 Unmanaged.slow_conv_transpose3d_out_tttltl
+
+slow_conv_transpose3d_out_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_out_tttlt = _cast5 Unmanaged.slow_conv_transpose3d_out_tttlt
+
+slow_conv_transpose3d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_out_tttl = _cast4 Unmanaged.slow_conv_transpose3d_out_tttl
+
+slow_conv_transpose3d_ttltllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_ttltllll = _cast8 Unmanaged.slow_conv_transpose3d_ttltllll
+
+slow_conv_transpose3d_ttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_ttltlll = _cast7 Unmanaged.slow_conv_transpose3d_ttltlll
+
+slow_conv_transpose3d_ttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_ttltll = _cast6 Unmanaged.slow_conv_transpose3d_ttltll
+
+slow_conv_transpose3d_ttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_ttltl = _cast5 Unmanaged.slow_conv_transpose3d_ttltl
+
+slow_conv_transpose3d_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_ttlt = _cast4 Unmanaged.slow_conv_transpose3d_ttlt
+
+slow_conv_transpose3d_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_transpose3d_ttl = _cast3 Unmanaged.slow_conv_transpose3d_ttl
+
+thnn_conv2d_out_tttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+thnn_conv2d_out_tttltll = _cast7 Unmanaged.thnn_conv2d_out_tttltll
+
+thnn_conv2d_out_tttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+thnn_conv2d_out_tttltl = _cast6 Unmanaged.thnn_conv2d_out_tttltl
+
+thnn_conv2d_out_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+thnn_conv2d_out_tttlt = _cast5 Unmanaged.thnn_conv2d_out_tttlt
+
+thnn_conv2d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+thnn_conv2d_out_tttl = _cast4 Unmanaged.thnn_conv2d_out_tttl
+
+thnn_conv2d_ttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+thnn_conv2d_ttltll = _cast6 Unmanaged.thnn_conv2d_ttltll
+
+thnn_conv2d_ttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+thnn_conv2d_ttltl = _cast5 Unmanaged.thnn_conv2d_ttltl
+
+thnn_conv2d_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+thnn_conv2d_ttlt = _cast4 Unmanaged.thnn_conv2d_ttlt
+
+thnn_conv2d_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+thnn_conv2d_ttl = _cast3 Unmanaged.thnn_conv2d_ttl
+
+_slow_conv2d_forward_out_tttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_slow_conv2d_forward_out_tttltll = _cast7 Unmanaged._slow_conv2d_forward_out_tttltll
+
+_slow_conv2d_forward_ttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_slow_conv2d_forward_ttltll = _cast6 Unmanaged._slow_conv2d_forward_ttltll
+
+_slow_conv2d_backward_out_ttttttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_slow_conv2d_backward_out_ttttttlll = _cast9 Unmanaged._slow_conv2d_backward_out_ttttttlll
+
+_slow_conv2d_backward_tttllla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_slow_conv2d_backward_tttllla = _cast7 Unmanaged._slow_conv2d_backward_tttllla
+
+_conv_depthwise2d_out_tttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_conv_depthwise2d_out_tttltlll = _cast8 Unmanaged._conv_depthwise2d_out_tttltlll
+
+_conv_depthwise2d_ttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_conv_depthwise2d_ttltlll = _cast7 Unmanaged._conv_depthwise2d_ttltlll
+
+conv_depthwise3d_ttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_depthwise3d_ttltlll = _cast7 Unmanaged.conv_depthwise3d_ttltlll
+
+slow_conv3d_out_tttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_out_tttltll = _cast7 Unmanaged.slow_conv3d_out_tttltll
+
+slow_conv3d_out_tttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_out_tttltl = _cast6 Unmanaged.slow_conv3d_out_tttltl
+
+slow_conv3d_out_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_out_tttlt = _cast5 Unmanaged.slow_conv3d_out_tttlt
+
+slow_conv3d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_out_tttl = _cast4 Unmanaged.slow_conv3d_out_tttl
+
+slow_conv3d_ttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_ttltll = _cast6 Unmanaged.slow_conv3d_ttltll
+
+slow_conv3d_ttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_ttltl = _cast5 Unmanaged.slow_conv3d_ttltl
+
+slow_conv3d_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_ttlt = _cast4 Unmanaged.slow_conv3d_ttlt
+
+slow_conv3d_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_ttl = _cast3 Unmanaged.slow_conv3d_ttl
+
+slow_conv3d_forward_out_tttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_forward_out_tttltll = _cast7 Unmanaged.slow_conv3d_forward_out_tttltll
+
+slow_conv3d_forward_ttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv3d_forward_ttltll = _cast6 Unmanaged.slow_conv3d_forward_ttltll
+
+slow_conv_dilated2d_ttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_ttltlll = _cast7 Unmanaged.slow_conv_dilated2d_ttltlll
+
+slow_conv_dilated2d_ttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_ttltll = _cast6 Unmanaged.slow_conv_dilated2d_ttltll
+
+slow_conv_dilated2d_ttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_ttltl = _cast5 Unmanaged.slow_conv_dilated2d_ttltl
+
+slow_conv_dilated2d_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_ttlt = _cast4 Unmanaged.slow_conv_dilated2d_ttlt
+
+slow_conv_dilated2d_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_ttl = _cast3 Unmanaged.slow_conv_dilated2d_ttl
+
+slow_conv_dilated3d_ttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_ttltlll = _cast7 Unmanaged.slow_conv_dilated3d_ttltlll
+
+slow_conv_dilated3d_ttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_ttltll = _cast6 Unmanaged.slow_conv_dilated3d_ttltll
+
+slow_conv_dilated3d_ttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_ttltl = _cast5 Unmanaged.slow_conv_dilated3d_ttltl
+
+slow_conv_dilated3d_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_ttlt = _cast4 Unmanaged.slow_conv_dilated3d_ttlt
+
+slow_conv_dilated3d_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_ttl = _cast3 Unmanaged.slow_conv_dilated3d_ttl
+
+col2im_out_ttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+col2im_out_ttlllll = _cast7 Unmanaged.col2im_out_ttlllll
+
+col2im_tlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+col2im_tlllll = _cast6 Unmanaged.col2im_tlllll
+
+column_stack_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+column_stack_l = _cast1 Unmanaged.column_stack_l
+
+column_stack_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+column_stack_out_tl = _cast2 Unmanaged.column_stack_out_tl
+
+im2col_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+im2col_out_ttllll = _cast6 Unmanaged.im2col_out_ttllll
+
+im2col_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+im2col_tllll = _cast5 Unmanaged.im2col_tllll
+
+isfinite_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isfinite_t = _cast1 Unmanaged.isfinite_t
+
+isinf_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isinf_t = _cast1 Unmanaged.isinf_t
+
+isposinf_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isposinf_t = _cast1 Unmanaged.isposinf_t
+
+isposinf_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isposinf_out_tt = _cast2 Unmanaged.isposinf_out_tt
+
+isneginf_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isneginf_t = _cast1 Unmanaged.isneginf_t
+
+isneginf_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isneginf_out_tt = _cast2 Unmanaged.isneginf_out_tt
+
+_add_batch_dim_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_add_batch_dim_tll = _cast3 Unmanaged._add_batch_dim_tll
+
+_remove_batch_dim_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_remove_batch_dim_tlll = _cast4 Unmanaged._remove_batch_dim_tlll
+
+special_entr_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_entr_t = _cast1 Unmanaged.special_entr_t
+
+special_entr_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_entr_out_tt = _cast2 Unmanaged.special_entr_out_tt
+
+special_ndtri_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_ndtri_t = _cast1 Unmanaged.special_ndtri_t
+
+special_ndtri_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_ndtri_out_tt = _cast2 Unmanaged.special_ndtri_out_tt
+
+special_log_ndtr_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_log_ndtr_t = _cast1 Unmanaged.special_log_ndtr_t
+
+special_log_ndtr_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_log_ndtr_out_tt = _cast2 Unmanaged.special_log_ndtr_out_tt
+
+special_expm1_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_expm1_t = _cast1 Unmanaged.special_expm1_t
+
+special_expm1_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_expm1_out_tt = _cast2 Unmanaged.special_expm1_out_tt
+
+special_exp2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_exp2_t = _cast1 Unmanaged.special_exp2_t
+
+special_exp2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_exp2_out_tt = _cast2 Unmanaged.special_exp2_out_tt
+
+special_psi_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_psi_t = _cast1 Unmanaged.special_psi_t
+
+special_psi_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_psi_out_tt = _cast2 Unmanaged.special_psi_out_tt
+
+special_digamma_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_digamma_t = _cast1 Unmanaged.special_digamma_t
+
+special_digamma_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_digamma_out_tt = _cast2 Unmanaged.special_digamma_out_tt
+
+special_gammaln_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_gammaln_t = _cast1 Unmanaged.special_gammaln_t
+
+special_gammaln_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_gammaln_out_tt = _cast2 Unmanaged.special_gammaln_out_tt
+
+special_erf_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_erf_t = _cast1 Unmanaged.special_erf_t
+
+special_erf_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_erf_out_tt = _cast2 Unmanaged.special_erf_out_tt
+
+special_erfc_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_erfc_t = _cast1 Unmanaged.special_erfc_t
+
+special_erfc_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_erfc_out_tt = _cast2 Unmanaged.special_erfc_out_tt
+
+special_erfcx_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_erfcx_t = _cast1 Unmanaged.special_erfcx_t
+
+special_erfcx_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_erfcx_out_tt = _cast2 Unmanaged.special_erfcx_out_tt
+
+special_erfinv_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_erfinv_t = _cast1 Unmanaged.special_erfinv_t
+
+special_erfinv_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_erfinv_out_tt = _cast2 Unmanaged.special_erfinv_out_tt
+
+special_ndtr_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_ndtr_t = _cast1 Unmanaged.special_ndtr_t
+
+special_ndtr_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_ndtr_out_tt = _cast2 Unmanaged.special_ndtr_out_tt
+
+special_xlog1py_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_xlog1py_tt = _cast2 Unmanaged.special_xlog1py_tt
+
+special_xlog1py_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_xlog1py_st = _cast2 Unmanaged.special_xlog1py_st
+
+special_xlog1py_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_xlog1py_ts = _cast2 Unmanaged.special_xlog1py_ts
+
+special_xlog1py_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_xlog1py_out_ttt = _cast3 Unmanaged.special_xlog1py_out_ttt
+
+special_xlog1py_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_xlog1py_out_tst = _cast3 Unmanaged.special_xlog1py_out_tst
+
+special_xlog1py_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_xlog1py_out_tts = _cast3 Unmanaged.special_xlog1py_out_tts
+
+special_xlogy_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_xlogy_tt = _cast2 Unmanaged.special_xlogy_tt
+
+special_xlogy_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_xlogy_st = _cast2 Unmanaged.special_xlogy_st
+
+special_xlogy_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_xlogy_ts = _cast2 Unmanaged.special_xlogy_ts
+
+special_xlogy_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_xlogy_out_ttt = _cast3 Unmanaged.special_xlogy_out_ttt
+
+special_xlogy_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_xlogy_out_tst = _cast3 Unmanaged.special_xlogy_out_tst
+
+special_xlogy_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_xlogy_out_tts = _cast3 Unmanaged.special_xlogy_out_tts
+
+special_zeta_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_zeta_tt = _cast2 Unmanaged.special_zeta_tt
+
+special_zeta_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_zeta_st = _cast2 Unmanaged.special_zeta_st
+
+special_zeta_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_zeta_ts = _cast2 Unmanaged.special_zeta_ts
+
+special_zeta_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_zeta_out_ttt = _cast3 Unmanaged.special_zeta_out_ttt
+
+special_zeta_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_zeta_out_tst = _cast3 Unmanaged.special_zeta_out_tst
+
+special_zeta_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_zeta_out_tts = _cast3 Unmanaged.special_zeta_out_tts
+
+special_i0_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_i0_t = _cast1 Unmanaged.special_i0_t
+
+special_i0_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_i0_out_tt = _cast2 Unmanaged.special_i0_out_tt
+
+special_i0e_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_i0e_t = _cast1 Unmanaged.special_i0e_t
+
+special_i0e_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_i0e_out_tt = _cast2 Unmanaged.special_i0e_out_tt
+
+special_i1_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_i1_t = _cast1 Unmanaged.special_i1_t
+
+special_i1_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_i1_out_tt = _cast2 Unmanaged.special_i1_out_tt
+
+special_i1e_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_i1e_t = _cast1 Unmanaged.special_i1e_t
+
+special_i1e_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_i1e_out_tt = _cast2 Unmanaged.special_i1e_out_tt
+
+special_logit_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+special_logit_td = _cast2 Unmanaged.special_logit_td
+
+special_logit_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_logit_t = _cast1 Unmanaged.special_logit_t
+
+special_logit_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+special_logit_out_ttd = _cast3 Unmanaged.special_logit_out_ttd
+
+special_logit_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_logit_out_tt = _cast2 Unmanaged.special_logit_out_tt
+
+special_polygamma_lt
+  :: Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_polygamma_lt = _cast2 Unmanaged.special_polygamma_lt
+
+special_polygamma_out_tlt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_polygamma_out_tlt = _cast3 Unmanaged.special_polygamma_out_tlt
+
+special_logsumexp_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+special_logsumexp_tlb = _cast3 Unmanaged.special_logsumexp_tlb
+
+special_logsumexp_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+special_logsumexp_tl = _cast2 Unmanaged.special_logsumexp_tl
+
+special_logsumexp_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+special_logsumexp_out_ttlb = _cast4 Unmanaged.special_logsumexp_out_ttlb
+
+special_logsumexp_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+special_logsumexp_out_ttl = _cast3 Unmanaged.special_logsumexp_out_ttl
+
+special_expit_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_expit_t = _cast1 Unmanaged.special_expit_t
+
+special_expit_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_expit_out_tt = _cast2 Unmanaged.special_expit_out_tt
+
+special_sinc_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_sinc_t = _cast1 Unmanaged.special_sinc_t
+
+special_sinc_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_sinc_out_tt = _cast2 Unmanaged.special_sinc_out_tt
+
+special_round_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+special_round_tl = _cast2 Unmanaged.special_round_tl
+
+special_round_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_round_t = _cast1 Unmanaged.special_round_t
+
+special_round_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+special_round_out_ttl = _cast3 Unmanaged.special_round_out_ttl
+
+special_round_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_round_out_tt = _cast2 Unmanaged.special_round_out_tt
+
+special_log1p_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_log1p_t = _cast1 Unmanaged.special_log1p_t
+
+special_log1p_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_log1p_out_tt = _cast2 Unmanaged.special_log1p_out_tt
+
+special_log_softmax_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+special_log_softmax_tls = _cast3 Unmanaged.special_log_softmax_tls
+
+special_log_softmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+special_log_softmax_tl = _cast2 Unmanaged.special_log_softmax_tl
+
+special_gammainc_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_gammainc_out_ttt = _cast3 Unmanaged.special_gammainc_out_ttt
+
+special_gammainc_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_gammainc_tt = _cast2 Unmanaged.special_gammainc_tt
+
+special_gammaincc_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_gammaincc_out_ttt = _cast3 Unmanaged.special_gammaincc_out_ttt
+
+special_gammaincc_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_gammaincc_tt = _cast2 Unmanaged.special_gammaincc_tt
+
+special_multigammaln_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+special_multigammaln_tl = _cast2 Unmanaged.special_multigammaln_tl
+
+special_multigammaln_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+special_multigammaln_out_ttl = _cast3 Unmanaged.special_multigammaln_out_ttl
+
+special_softmax_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+special_softmax_tls = _cast3 Unmanaged.special_softmax_tls
+
+special_softmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+special_softmax_tl = _cast2 Unmanaged.special_softmax_tl
+
+fft_fft_tlls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_fft_tlls = _cast4 Unmanaged.fft_fft_tlls
+
+fft_fft_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_fft_tll = _cast3 Unmanaged.fft_fft_tll
+
+fft_fft_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_fft_tl = _cast2 Unmanaged.fft_fft_tl
+
+fft_fft_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_fft_t = _cast1 Unmanaged.fft_fft_t
+
+fft_fft_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_fft_out_ttlls = _cast5 Unmanaged.fft_fft_out_ttlls
+
+fft_fft_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_fft_out_ttll = _cast4 Unmanaged.fft_fft_out_ttll
+
+fft_fft_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_fft_out_ttl = _cast3 Unmanaged.fft_fft_out_ttl
+
+fft_fft_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_fft_out_tt = _cast2 Unmanaged.fft_fft_out_tt
+
+fft_ifft_tlls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ifft_tlls = _cast4 Unmanaged.fft_ifft_tlls
+
+fft_ifft_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_ifft_tll = _cast3 Unmanaged.fft_ifft_tll
+
+fft_ifft_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_ifft_tl = _cast2 Unmanaged.fft_ifft_tl
+
+fft_ifft_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ifft_t = _cast1 Unmanaged.fft_ifft_t
+
+fft_ifft_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ifft_out_ttlls = _cast5 Unmanaged.fft_ifft_out_ttlls
+
+fft_ifft_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_ifft_out_ttll = _cast4 Unmanaged.fft_ifft_out_ttll
+
+fft_ifft_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_ifft_out_ttl = _cast3 Unmanaged.fft_ifft_out_ttl
+
+fft_ifft_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ifft_out_tt = _cast2 Unmanaged.fft_ifft_out_tt
+
+fft_rfft_tlls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_rfft_tlls = _cast4 Unmanaged.fft_rfft_tlls
+
+fft_rfft_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_rfft_tll = _cast3 Unmanaged.fft_rfft_tll
+
+fft_rfft_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_rfft_tl = _cast2 Unmanaged.fft_rfft_tl
+
+fft_rfft_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_rfft_t = _cast1 Unmanaged.fft_rfft_t
+
+fft_rfft_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_rfft_out_ttlls = _cast5 Unmanaged.fft_rfft_out_ttlls
+
+fft_rfft_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_rfft_out_ttll = _cast4 Unmanaged.fft_rfft_out_ttll
+
+fft_rfft_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_rfft_out_ttl = _cast3 Unmanaged.fft_rfft_out_ttl
+
diff --git a/src/Torch/Internal/Managed/Native/Native11.hs b/src/Torch/Internal/Managed/Native/Native11.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native11.hs
@@ -0,0 +1,1938 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native11 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native11 as Unmanaged
+
+
+fft_rfft_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_rfft_out_tt = _cast2 Unmanaged.fft_rfft_out_tt
+
+fft_irfft_tlls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_irfft_tlls = _cast4 Unmanaged.fft_irfft_tlls
+
+fft_irfft_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_irfft_tll = _cast3 Unmanaged.fft_irfft_tll
+
+fft_irfft_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_irfft_tl = _cast2 Unmanaged.fft_irfft_tl
+
+fft_irfft_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_irfft_t = _cast1 Unmanaged.fft_irfft_t
+
+fft_irfft_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_irfft_out_ttlls = _cast5 Unmanaged.fft_irfft_out_ttlls
+
+fft_irfft_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_irfft_out_ttll = _cast4 Unmanaged.fft_irfft_out_ttll
+
+fft_irfft_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_irfft_out_ttl = _cast3 Unmanaged.fft_irfft_out_ttl
+
+fft_irfft_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_irfft_out_tt = _cast2 Unmanaged.fft_irfft_out_tt
+
+fft_hfft_tlls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_hfft_tlls = _cast4 Unmanaged.fft_hfft_tlls
+
+fft_hfft_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_hfft_tll = _cast3 Unmanaged.fft_hfft_tll
+
+fft_hfft_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_hfft_tl = _cast2 Unmanaged.fft_hfft_tl
+
+fft_hfft_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_hfft_t = _cast1 Unmanaged.fft_hfft_t
+
+fft_hfft_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_hfft_out_ttlls = _cast5 Unmanaged.fft_hfft_out_ttlls
+
+fft_hfft_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_hfft_out_ttll = _cast4 Unmanaged.fft_hfft_out_ttll
+
+fft_hfft_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_hfft_out_ttl = _cast3 Unmanaged.fft_hfft_out_ttl
+
+fft_hfft_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_hfft_out_tt = _cast2 Unmanaged.fft_hfft_out_tt
+
+fft_ihfft_tlls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ihfft_tlls = _cast4 Unmanaged.fft_ihfft_tlls
+
+fft_ihfft_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_ihfft_tll = _cast3 Unmanaged.fft_ihfft_tll
+
+fft_ihfft_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_ihfft_tl = _cast2 Unmanaged.fft_ihfft_tl
+
+fft_ihfft_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ihfft_t = _cast1 Unmanaged.fft_ihfft_t
+
+fft_ihfft_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ihfft_out_ttlls = _cast5 Unmanaged.fft_ihfft_out_ttlls
+
+fft_ihfft_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_ihfft_out_ttll = _cast4 Unmanaged.fft_ihfft_out_ttll
+
+fft_ihfft_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_ihfft_out_ttl = _cast3 Unmanaged.fft_ihfft_out_ttl
+
+fft_ihfft_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ihfft_out_tt = _cast2 Unmanaged.fft_ihfft_out_tt
+
+fft_fft2_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_fft2_tlls = _cast4 Unmanaged.fft_fft2_tlls
+
+fft_fft2_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fft2_tll = _cast3 Unmanaged.fft_fft2_tll
+
+fft_fft2_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fft2_tl = _cast2 Unmanaged.fft_fft2_tl
+
+fft_fft2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_fft2_t = _cast1 Unmanaged.fft_fft2_t
+
+fft_fft2_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_fft2_out_ttlls = _cast5 Unmanaged.fft_fft2_out_ttlls
+
+fft_fft2_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fft2_out_ttll = _cast4 Unmanaged.fft_fft2_out_ttll
+
+fft_fft2_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fft2_out_ttl = _cast3 Unmanaged.fft_fft2_out_ttl
+
+fft_fft2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_fft2_out_tt = _cast2 Unmanaged.fft_fft2_out_tt
+
+fft_ifft2_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ifft2_tlls = _cast4 Unmanaged.fft_ifft2_tlls
+
+fft_ifft2_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifft2_tll = _cast3 Unmanaged.fft_ifft2_tll
+
+fft_ifft2_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifft2_tl = _cast2 Unmanaged.fft_ifft2_tl
+
+fft_ifft2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ifft2_t = _cast1 Unmanaged.fft_ifft2_t
+
+fft_ifft2_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ifft2_out_ttlls = _cast5 Unmanaged.fft_ifft2_out_ttlls
+
+fft_ifft2_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifft2_out_ttll = _cast4 Unmanaged.fft_ifft2_out_ttll
+
+fft_ifft2_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifft2_out_ttl = _cast3 Unmanaged.fft_ifft2_out_ttl
+
+fft_ifft2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ifft2_out_tt = _cast2 Unmanaged.fft_ifft2_out_tt
+
+fft_rfft2_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_rfft2_tlls = _cast4 Unmanaged.fft_rfft2_tlls
+
+fft_rfft2_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_rfft2_tll = _cast3 Unmanaged.fft_rfft2_tll
+
+fft_rfft2_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_rfft2_tl = _cast2 Unmanaged.fft_rfft2_tl
+
+fft_rfft2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_rfft2_t = _cast1 Unmanaged.fft_rfft2_t
+
+fft_rfft2_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_rfft2_out_ttlls = _cast5 Unmanaged.fft_rfft2_out_ttlls
+
+fft_rfft2_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_rfft2_out_ttll = _cast4 Unmanaged.fft_rfft2_out_ttll
+
+fft_rfft2_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_rfft2_out_ttl = _cast3 Unmanaged.fft_rfft2_out_ttl
+
+fft_rfft2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_rfft2_out_tt = _cast2 Unmanaged.fft_rfft2_out_tt
+
+fft_irfft2_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_irfft2_tlls = _cast4 Unmanaged.fft_irfft2_tlls
+
+fft_irfft2_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_irfft2_tll = _cast3 Unmanaged.fft_irfft2_tll
+
+fft_irfft2_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_irfft2_tl = _cast2 Unmanaged.fft_irfft2_tl
+
+fft_irfft2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_irfft2_t = _cast1 Unmanaged.fft_irfft2_t
+
+fft_irfft2_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_irfft2_out_ttlls = _cast5 Unmanaged.fft_irfft2_out_ttlls
+
+fft_irfft2_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_irfft2_out_ttll = _cast4 Unmanaged.fft_irfft2_out_ttll
+
+fft_irfft2_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_irfft2_out_ttl = _cast3 Unmanaged.fft_irfft2_out_ttl
+
+fft_irfft2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_irfft2_out_tt = _cast2 Unmanaged.fft_irfft2_out_tt
+
+fft_hfft2_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_hfft2_tlls = _cast4 Unmanaged.fft_hfft2_tlls
+
+fft_hfft2_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_hfft2_tll = _cast3 Unmanaged.fft_hfft2_tll
+
+fft_hfft2_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_hfft2_tl = _cast2 Unmanaged.fft_hfft2_tl
+
+fft_hfft2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_hfft2_t = _cast1 Unmanaged.fft_hfft2_t
+
+fft_hfft2_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_hfft2_out_ttlls = _cast5 Unmanaged.fft_hfft2_out_ttlls
+
+fft_hfft2_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_hfft2_out_ttll = _cast4 Unmanaged.fft_hfft2_out_ttll
+
+fft_hfft2_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_hfft2_out_ttl = _cast3 Unmanaged.fft_hfft2_out_ttl
+
+fft_hfft2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_hfft2_out_tt = _cast2 Unmanaged.fft_hfft2_out_tt
+
+fft_ihfft2_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ihfft2_tlls = _cast4 Unmanaged.fft_ihfft2_tlls
+
+fft_ihfft2_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ihfft2_tll = _cast3 Unmanaged.fft_ihfft2_tll
+
+fft_ihfft2_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ihfft2_tl = _cast2 Unmanaged.fft_ihfft2_tl
+
+fft_ihfft2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ihfft2_t = _cast1 Unmanaged.fft_ihfft2_t
+
+fft_ihfft2_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ihfft2_out_ttlls = _cast5 Unmanaged.fft_ihfft2_out_ttlls
+
+fft_ihfft2_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ihfft2_out_ttll = _cast4 Unmanaged.fft_ihfft2_out_ttll
+
+fft_ihfft2_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ihfft2_out_ttl = _cast3 Unmanaged.fft_ihfft2_out_ttl
+
+fft_ihfft2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ihfft2_out_tt = _cast2 Unmanaged.fft_ihfft2_out_tt
+
+fft_fftn_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_fftn_tlls = _cast4 Unmanaged.fft_fftn_tlls
+
+fft_fftn_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fftn_tll = _cast3 Unmanaged.fft_fftn_tll
+
+fft_fftn_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fftn_tl = _cast2 Unmanaged.fft_fftn_tl
+
+fft_fftn_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_fftn_t = _cast1 Unmanaged.fft_fftn_t
+
+fft_fftn_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_fftn_out_ttlls = _cast5 Unmanaged.fft_fftn_out_ttlls
+
+fft_fftn_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fftn_out_ttll = _cast4 Unmanaged.fft_fftn_out_ttll
+
+fft_fftn_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fftn_out_ttl = _cast3 Unmanaged.fft_fftn_out_ttl
+
+fft_fftn_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_fftn_out_tt = _cast2 Unmanaged.fft_fftn_out_tt
+
+fft_ifftn_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ifftn_tlls = _cast4 Unmanaged.fft_ifftn_tlls
+
+fft_ifftn_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifftn_tll = _cast3 Unmanaged.fft_ifftn_tll
+
+fft_ifftn_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifftn_tl = _cast2 Unmanaged.fft_ifftn_tl
+
+fft_ifftn_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ifftn_t = _cast1 Unmanaged.fft_ifftn_t
+
+fft_ifftn_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ifftn_out_ttlls = _cast5 Unmanaged.fft_ifftn_out_ttlls
+
+fft_ifftn_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifftn_out_ttll = _cast4 Unmanaged.fft_ifftn_out_ttll
+
+fft_ifftn_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifftn_out_ttl = _cast3 Unmanaged.fft_ifftn_out_ttl
+
+fft_ifftn_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ifftn_out_tt = _cast2 Unmanaged.fft_ifftn_out_tt
+
+fft_rfftn_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_rfftn_tlls = _cast4 Unmanaged.fft_rfftn_tlls
+
+fft_rfftn_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_rfftn_tll = _cast3 Unmanaged.fft_rfftn_tll
+
+fft_rfftn_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_rfftn_tl = _cast2 Unmanaged.fft_rfftn_tl
+
+fft_rfftn_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_rfftn_t = _cast1 Unmanaged.fft_rfftn_t
+
+fft_rfftn_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_rfftn_out_ttlls = _cast5 Unmanaged.fft_rfftn_out_ttlls
+
+fft_rfftn_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_rfftn_out_ttll = _cast4 Unmanaged.fft_rfftn_out_ttll
+
+fft_rfftn_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_rfftn_out_ttl = _cast3 Unmanaged.fft_rfftn_out_ttl
+
+fft_rfftn_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_rfftn_out_tt = _cast2 Unmanaged.fft_rfftn_out_tt
+
+fft_irfftn_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_irfftn_tlls = _cast4 Unmanaged.fft_irfftn_tlls
+
+fft_irfftn_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_irfftn_tll = _cast3 Unmanaged.fft_irfftn_tll
+
+fft_irfftn_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_irfftn_tl = _cast2 Unmanaged.fft_irfftn_tl
+
+fft_irfftn_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_irfftn_t = _cast1 Unmanaged.fft_irfftn_t
+
+fft_irfftn_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_irfftn_out_ttlls = _cast5 Unmanaged.fft_irfftn_out_ttlls
+
+fft_irfftn_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_irfftn_out_ttll = _cast4 Unmanaged.fft_irfftn_out_ttll
+
+fft_irfftn_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_irfftn_out_ttl = _cast3 Unmanaged.fft_irfftn_out_ttl
+
+fft_irfftn_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_irfftn_out_tt = _cast2 Unmanaged.fft_irfftn_out_tt
+
+fft_hfftn_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_hfftn_tlls = _cast4 Unmanaged.fft_hfftn_tlls
+
+fft_hfftn_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_hfftn_tll = _cast3 Unmanaged.fft_hfftn_tll
+
+fft_hfftn_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_hfftn_tl = _cast2 Unmanaged.fft_hfftn_tl
+
+fft_hfftn_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_hfftn_t = _cast1 Unmanaged.fft_hfftn_t
+
+fft_hfftn_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_hfftn_out_ttlls = _cast5 Unmanaged.fft_hfftn_out_ttlls
+
+fft_hfftn_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_hfftn_out_ttll = _cast4 Unmanaged.fft_hfftn_out_ttll
+
+fft_hfftn_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_hfftn_out_ttl = _cast3 Unmanaged.fft_hfftn_out_ttl
+
+fft_hfftn_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_hfftn_out_tt = _cast2 Unmanaged.fft_hfftn_out_tt
+
+fft_ihfftn_tlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ihfftn_tlls = _cast4 Unmanaged.fft_ihfftn_tlls
+
+fft_ihfftn_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ihfftn_tll = _cast3 Unmanaged.fft_ihfftn_tll
+
+fft_ihfftn_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ihfftn_tl = _cast2 Unmanaged.fft_ihfftn_tl
+
+fft_ihfftn_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ihfftn_t = _cast1 Unmanaged.fft_ihfftn_t
+
+fft_ihfftn_out_ttlls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+fft_ihfftn_out_ttlls = _cast5 Unmanaged.fft_ihfftn_out_ttlls
+
+fft_ihfftn_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ihfftn_out_ttll = _cast4 Unmanaged.fft_ihfftn_out_ttll
+
+fft_ihfftn_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ihfftn_out_ttl = _cast3 Unmanaged.fft_ihfftn_out_ttl
+
+fft_ihfftn_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ihfftn_out_tt = _cast2 Unmanaged.fft_ihfftn_out_tt
+
+fft_fftfreq_ldo
+  :: Int64
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+fft_fftfreq_ldo = _cast3 Unmanaged.fft_fftfreq_ldo
+
+fft_fftfreq_ld
+  :: Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+fft_fftfreq_ld = _cast2 Unmanaged.fft_fftfreq_ld
+
+fft_fftfreq_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+fft_fftfreq_l = _cast1 Unmanaged.fft_fftfreq_l
+
+fft_fftfreq_out_tld
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+fft_fftfreq_out_tld = _cast3 Unmanaged.fft_fftfreq_out_tld
+
+fft_fftfreq_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_fftfreq_out_tl = _cast2 Unmanaged.fft_fftfreq_out_tl
+
+fft_rfftfreq_ldo
+  :: Int64
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+fft_rfftfreq_ldo = _cast3 Unmanaged.fft_rfftfreq_ldo
+
+fft_rfftfreq_ld
+  :: Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+fft_rfftfreq_ld = _cast2 Unmanaged.fft_rfftfreq_ld
+
+fft_rfftfreq_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+fft_rfftfreq_l = _cast1 Unmanaged.fft_rfftfreq_l
+
+fft_rfftfreq_out_tld
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+fft_rfftfreq_out_tld = _cast3 Unmanaged.fft_rfftfreq_out_tld
+
+fft_rfftfreq_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fft_rfftfreq_out_tl = _cast2 Unmanaged.fft_rfftfreq_out_tl
+
+fft_fftshift_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_fftshift_tl = _cast2 Unmanaged.fft_fftshift_tl
+
+fft_fftshift_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_fftshift_t = _cast1 Unmanaged.fft_fftshift_t
+
+fft_ifftshift_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+fft_ifftshift_tl = _cast2 Unmanaged.fft_ifftshift_tl
+
+fft_ifftshift_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fft_ifftshift_t = _cast1 Unmanaged.fft_ifftshift_t
+
+linalg_cholesky_ex_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_tbb = _cast3 Unmanaged.linalg_cholesky_ex_tbb
+
+linalg_cholesky_ex_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_tb = _cast2 Unmanaged.linalg_cholesky_ex_tb
+
+linalg_cholesky_ex_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_t = _cast1 Unmanaged.linalg_cholesky_ex_t
+
+linalg_cholesky_ex_out_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_out_tttbb = _cast5 Unmanaged.linalg_cholesky_ex_out_tttbb
+
+linalg_cholesky_ex_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_out_tttb = _cast4 Unmanaged.linalg_cholesky_ex_out_tttb
+
+linalg_cholesky_ex_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_out_ttt = _cast3 Unmanaged.linalg_cholesky_ex_out_ttt
+
+linalg_cholesky_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_cholesky_tb = _cast2 Unmanaged.linalg_cholesky_tb
+
+linalg_cholesky_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_cholesky_t = _cast1 Unmanaged.linalg_cholesky_t
+
+linalg_cholesky_out_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_cholesky_out_ttb = _cast3 Unmanaged.linalg_cholesky_out_ttb
+
+linalg_cholesky_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_cholesky_out_tt = _cast2 Unmanaged.linalg_cholesky_out_tt
+
+linalg_cross_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_cross_ttl = _cast3 Unmanaged.linalg_cross_ttl
+
+linalg_cross_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_cross_tt = _cast2 Unmanaged.linalg_cross_tt
+
+linalg_cross_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_cross_out_tttl = _cast4 Unmanaged.linalg_cross_out_tttl
+
+linalg_cross_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_cross_out_ttt = _cast3 Unmanaged.linalg_cross_out_ttt
+
+linalg_lu_factor_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_lu_factor_tb = _cast2 Unmanaged.linalg_lu_factor_tb
+
+linalg_lu_factor_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_lu_factor_t = _cast1 Unmanaged.linalg_lu_factor_t
+
+linalg_lu_factor_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_lu_factor_out_tttb = _cast4 Unmanaged.linalg_lu_factor_out_tttb
+
+linalg_lu_factor_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_lu_factor_out_ttt = _cast3 Unmanaged.linalg_lu_factor_out_ttt
+
+linalg_lu_factor_ex_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_tbb = _cast3 Unmanaged.linalg_lu_factor_ex_tbb
+
+linalg_lu_factor_ex_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_tb = _cast2 Unmanaged.linalg_lu_factor_ex_tb
+
+linalg_lu_factor_ex_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_t = _cast1 Unmanaged.linalg_lu_factor_ex_t
+
+linalg_lu_factor_ex_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_out_ttttbb = _cast6 Unmanaged.linalg_lu_factor_ex_out_ttttbb
+
+linalg_lu_factor_ex_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_out_ttttb = _cast5 Unmanaged.linalg_lu_factor_ex_out_ttttb
+
+linalg_lu_factor_ex_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_out_tttt = _cast4 Unmanaged.linalg_lu_factor_ex_out_tttt
+
+linalg_lu_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_tb = _cast2 Unmanaged.linalg_lu_tb
+
+linalg_lu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_t = _cast1 Unmanaged.linalg_lu_t
+
+linalg_lu_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_out_ttttb = _cast5 Unmanaged.linalg_lu_out_ttttb
+
+linalg_lu_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_out_tttt = _cast4 Unmanaged.linalg_lu_out_tttt
+
+linalg_lu_solve_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_lu_solve_tttbb = _cast5 Unmanaged.linalg_lu_solve_tttbb
+
+linalg_lu_solve_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_lu_solve_tttb = _cast4 Unmanaged.linalg_lu_solve_tttb
+
+linalg_lu_solve_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_lu_solve_ttt = _cast3 Unmanaged.linalg_lu_solve_ttt
+
+linalg_lu_solve_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_lu_solve_out_ttttbb = _cast6 Unmanaged.linalg_lu_solve_out_ttttbb
+
+linalg_lu_solve_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_lu_solve_out_ttttb = _cast5 Unmanaged.linalg_lu_solve_out_ttttb
+
+linalg_lu_solve_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_lu_solve_out_tttt = _cast4 Unmanaged.linalg_lu_solve_out_tttt
+
+_linalg_det_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_det_t = _cast1 Unmanaged._linalg_det_t
+
+_linalg_det_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_det_out_tttt = _cast4 Unmanaged._linalg_det_out_tttt
+
+linalg_det_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_det_t = _cast1 Unmanaged.linalg_det_t
+
+linalg_det_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_det_out_tt = _cast2 Unmanaged.linalg_det_out_tt
+
+det_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+det_t = _cast1 Unmanaged.det_t
+
+linalg_ldl_factor_ex_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_tbb = _cast3 Unmanaged.linalg_ldl_factor_ex_tbb
+
+linalg_ldl_factor_ex_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_tb = _cast2 Unmanaged.linalg_ldl_factor_ex_tb
+
+linalg_ldl_factor_ex_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_t = _cast1 Unmanaged.linalg_ldl_factor_ex_t
+
+linalg_ldl_factor_ex_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_out_ttttbb = _cast6 Unmanaged.linalg_ldl_factor_ex_out_ttttbb
+
+linalg_ldl_factor_ex_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_out_ttttb = _cast5 Unmanaged.linalg_ldl_factor_ex_out_ttttb
+
+linalg_ldl_factor_ex_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_out_tttt = _cast4 Unmanaged.linalg_ldl_factor_ex_out_tttt
+
+linalg_ldl_factor_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_ldl_factor_tb = _cast2 Unmanaged.linalg_ldl_factor_tb
+
+linalg_ldl_factor_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_ldl_factor_t = _cast1 Unmanaged.linalg_ldl_factor_t
+
+linalg_ldl_factor_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_ldl_factor_out_tttb = _cast4 Unmanaged.linalg_ldl_factor_out_tttb
+
+linalg_ldl_factor_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_ldl_factor_out_ttt = _cast3 Unmanaged.linalg_ldl_factor_out_ttt
+
+linalg_ldl_solve_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_ldl_solve_tttb = _cast4 Unmanaged.linalg_ldl_solve_tttb
+
+linalg_ldl_solve_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_ldl_solve_ttt = _cast3 Unmanaged.linalg_ldl_solve_ttt
+
+linalg_ldl_solve_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_ldl_solve_out_ttttb = _cast5 Unmanaged.linalg_ldl_solve_out_ttttb
+
+linalg_ldl_solve_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_ldl_solve_out_tttt = _cast4 Unmanaged.linalg_ldl_solve_out_tttt
+
+linalg_lstsq_ttds
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_ttds = _cast4 Unmanaged.linalg_lstsq_ttds
+
+linalg_lstsq_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_ttd = _cast3 Unmanaged.linalg_lstsq_ttd
+
+linalg_lstsq_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_tt = _cast2 Unmanaged.linalg_lstsq_tt
+
+linalg_lstsq_out_ttttttds
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_out_ttttttds = _cast8 Unmanaged.linalg_lstsq_out_ttttttds
+
+linalg_lstsq_out_ttttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_out_ttttttd = _cast7 Unmanaged.linalg_lstsq_out_ttttttd
+
+linalg_lstsq_out_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_out_tttttt = _cast6 Unmanaged.linalg_lstsq_out_tttttt
+
+linalg_matmul_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matmul_tt = _cast2 Unmanaged.linalg_matmul_tt
+
+linalg_matmul_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matmul_out_ttt = _cast3 Unmanaged.linalg_matmul_out_ttt
+
+linalg_vecdot_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_vecdot_ttl = _cast3 Unmanaged.linalg_vecdot_ttl
+
+linalg_vecdot_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_vecdot_tt = _cast2 Unmanaged.linalg_vecdot_tt
+
+linalg_vecdot_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_vecdot_out_tttl = _cast4 Unmanaged.linalg_vecdot_out_tttl
+
+linalg_vecdot_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_vecdot_out_ttt = _cast3 Unmanaged.linalg_vecdot_out_ttt
+
+linalg_matrix_exp_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_exp_t = _cast1 Unmanaged.linalg_matrix_exp_t
+
+_linalg_slogdet_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_slogdet_t = _cast1 Unmanaged._linalg_slogdet_t
+
+_linalg_slogdet_out_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_slogdet_out_ttttt = _cast5 Unmanaged._linalg_slogdet_out_ttttt
+
+linalg_slogdet_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_slogdet_t = _cast1 Unmanaged.linalg_slogdet_t
+
+linalg_slogdet_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_slogdet_out_ttt = _cast3 Unmanaged.linalg_slogdet_out_ttt
+
+slogdet_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+slogdet_t = _cast1 Unmanaged.slogdet_t
+
+slogdet_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+slogdet_out_ttt = _cast3 Unmanaged.slogdet_out_ttt
+
+logdet_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logdet_t = _cast1 Unmanaged.logdet_t
+
+linalg_eig_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_eig_t = _cast1 Unmanaged.linalg_eig_t
+
+linalg_eig_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_eig_out_ttt = _cast3 Unmanaged.linalg_eig_out_ttt
+
+linalg_eigvals_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_eigvals_t = _cast1 Unmanaged.linalg_eigvals_t
+
+linalg_eigvals_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_eigvals_out_tt = _cast2 Unmanaged.linalg_eigvals_out_tt
+
+_linalg_eigh_tsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_tsb = _cast3 Unmanaged._linalg_eigh_tsb
+
+_linalg_eigh_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_ts = _cast2 Unmanaged._linalg_eigh_ts
+
+_linalg_eigh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_t = _cast1 Unmanaged._linalg_eigh_t
+
+_linalg_eigh_out_tttsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_out_tttsb = _cast5 Unmanaged._linalg_eigh_out_tttsb
+
+_linalg_eigh_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_out_ttts = _cast4 Unmanaged._linalg_eigh_out_ttts
+
+_linalg_eigh_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_out_ttt = _cast3 Unmanaged._linalg_eigh_out_ttt
+
+linalg_eigh_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_eigh_ts = _cast2 Unmanaged.linalg_eigh_ts
+
+linalg_eigh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_eigh_t = _cast1 Unmanaged.linalg_eigh_t
+
+linalg_eigh_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_eigh_out_ttts = _cast4 Unmanaged.linalg_eigh_out_ttts
+
+linalg_eigh_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_eigh_out_ttt = _cast3 Unmanaged.linalg_eigh_out_ttt
+
+linalg_eigvalsh_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+linalg_eigvalsh_ts = _cast2 Unmanaged.linalg_eigvalsh_ts
+
+linalg_eigvalsh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_eigvalsh_t = _cast1 Unmanaged.linalg_eigvalsh_t
+
+linalg_eigvalsh_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+linalg_eigvalsh_out_tts = _cast3 Unmanaged.linalg_eigvalsh_out_tts
+
+linalg_eigvalsh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_eigvalsh_out_tt = _cast2 Unmanaged.linalg_eigvalsh_out_tt
+
+linalg_householder_product_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_householder_product_tt = _cast2 Unmanaged.linalg_householder_product_tt
+
+linalg_householder_product_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_householder_product_out_ttt = _cast3 Unmanaged.linalg_householder_product_out_ttt
+
+linalg_inv_ex_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_inv_ex_tb = _cast2 Unmanaged.linalg_inv_ex_tb
+
+linalg_inv_ex_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_inv_ex_t = _cast1 Unmanaged.linalg_inv_ex_t
+
+linalg_inv_ex_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_inv_ex_out_tttb = _cast4 Unmanaged.linalg_inv_ex_out_tttb
+
+linalg_inv_ex_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_inv_ex_out_ttt = _cast3 Unmanaged.linalg_inv_ex_out_ttt
+
+linalg_inv_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_inv_t = _cast1 Unmanaged.linalg_inv_t
+
+linalg_inv_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_inv_out_tt = _cast2 Unmanaged.linalg_inv_out_tt
+
+inverse_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+inverse_t = _cast1 Unmanaged.inverse_t
+
+inverse_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+inverse_out_tt = _cast2 Unmanaged.inverse_out_tt
+
+inner_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+inner_tt = _cast2 Unmanaged.inner_tt
+
+inner_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+inner_out_ttt = _cast3 Unmanaged.inner_out_ttt
+
+outer_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+outer_tt = _cast2 Unmanaged.outer_tt
+
+outer_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+outer_out_ttt = _cast3 Unmanaged.outer_out_ttt
+
+ger_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ger_tt = _cast2 Unmanaged.ger_tt
+
+ger_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ger_out_ttt = _cast3 Unmanaged.ger_out_ttt
+
+linalg_norm_tslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+linalg_norm_tslbs = _cast5 Unmanaged.linalg_norm_tslbs
+
+linalg_norm_tslb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_norm_tslb = _cast4 Unmanaged.linalg_norm_tslb
+
+linalg_norm_tsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+linalg_norm_tsl = _cast3 Unmanaged.linalg_norm_tsl
+
+linalg_norm_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+linalg_norm_ts = _cast2 Unmanaged.linalg_norm_ts
+
+linalg_norm_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_norm_t = _cast1 Unmanaged.linalg_norm_t
+
+linalg_norm_out_ttslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+linalg_norm_out_ttslbs = _cast6 Unmanaged.linalg_norm_out_ttslbs
+
+linalg_norm_out_ttslb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_norm_out_ttslb = _cast5 Unmanaged.linalg_norm_out_ttslb
+
+linalg_norm_out_ttsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+linalg_norm_out_ttsl = _cast4 Unmanaged.linalg_norm_out_ttsl
+
+linalg_norm_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+linalg_norm_out_tts = _cast3 Unmanaged.linalg_norm_out_tts
+
+linalg_norm_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_norm_out_tt = _cast2 Unmanaged.linalg_norm_out_tt
+
+linalg_vector_norm_tslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_tslbs = _cast5 Unmanaged.linalg_vector_norm_tslbs
+
+linalg_vector_norm_tslb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_tslb = _cast4 Unmanaged.linalg_vector_norm_tslb
+
+linalg_vector_norm_tsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_tsl = _cast3 Unmanaged.linalg_vector_norm_tsl
+
+linalg_vector_norm_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_ts = _cast2 Unmanaged.linalg_vector_norm_ts
+
+linalg_vector_norm_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_t = _cast1 Unmanaged.linalg_vector_norm_t
+
+linalg_vector_norm_out_ttslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_out_ttslbs = _cast6 Unmanaged.linalg_vector_norm_out_ttslbs
+
+linalg_vector_norm_out_ttslb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_out_ttslb = _cast5 Unmanaged.linalg_vector_norm_out_ttslb
+
+linalg_vector_norm_out_ttsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_out_ttsl = _cast4 Unmanaged.linalg_vector_norm_out_ttsl
+
+linalg_vector_norm_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_out_tts = _cast3 Unmanaged.linalg_vector_norm_out_tts
+
+linalg_vector_norm_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_vector_norm_out_tt = _cast2 Unmanaged.linalg_vector_norm_out_tt
+
+linalg_matrix_norm_tslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_tslbs = _cast5 Unmanaged.linalg_matrix_norm_tslbs
+
+linalg_matrix_norm_tslb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_tslb = _cast4 Unmanaged.linalg_matrix_norm_tslb
+
+linalg_matrix_norm_tsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_tsl = _cast3 Unmanaged.linalg_matrix_norm_tsl
+
+linalg_matrix_norm_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_ts = _cast2 Unmanaged.linalg_matrix_norm_ts
+
+linalg_matrix_norm_out_ttslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_out_ttslbs = _cast6 Unmanaged.linalg_matrix_norm_out_ttslbs
+
+linalg_matrix_norm_out_ttslb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_out_ttslb = _cast5 Unmanaged.linalg_matrix_norm_out_ttslb
+
+linalg_matrix_norm_out_ttsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_out_ttsl = _cast4 Unmanaged.linalg_matrix_norm_out_ttsl
+
+linalg_matrix_norm_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_out_tts = _cast3 Unmanaged.linalg_matrix_norm_out_tts
+
+linalg_matrix_norm_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_t = _cast1 Unmanaged.linalg_matrix_norm_t
+
+linalg_matrix_norm_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_norm_out_tt = _cast2 Unmanaged.linalg_matrix_norm_out_tt
+
+_linalg_svd_tbbs
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_tbbs = _cast4 Unmanaged._linalg_svd_tbbs
+
+_linalg_svd_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_tbb = _cast3 Unmanaged._linalg_svd_tbb
+
+_linalg_svd_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_tb = _cast2 Unmanaged._linalg_svd_tb
+
+_linalg_svd_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_t = _cast1 Unmanaged._linalg_svd_t
+
diff --git a/src/Torch/Internal/Managed/Native/Native12.hs b/src/Torch/Internal/Managed/Native/Native12.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native12.hs
@@ -0,0 +1,1736 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native12 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native12 as Unmanaged
+
+
+_linalg_svd_out_ttttbbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_out_ttttbbs = _cast7 Unmanaged._linalg_svd_out_ttttbbs
+
+_linalg_svd_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_out_ttttbb = _cast6 Unmanaged._linalg_svd_out_ttttbb
+
+_linalg_svd_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_out_ttttb = _cast5 Unmanaged._linalg_svd_out_ttttb
+
+_linalg_svd_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_out_tttt = _cast4 Unmanaged._linalg_svd_out_tttt
+
+linalg_svd_tbs
+  :: ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_tbs = _cast3 Unmanaged.linalg_svd_tbs
+
+linalg_svd_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_tb = _cast2 Unmanaged.linalg_svd_tb
+
+linalg_svd_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_t = _cast1 Unmanaged.linalg_svd_t
+
+linalg_svd_out_ttttbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_out_ttttbs = _cast6 Unmanaged.linalg_svd_out_ttttbs
+
+linalg_svd_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_out_ttttb = _cast5 Unmanaged.linalg_svd_out_ttttb
+
+linalg_svd_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_out_tttt = _cast4 Unmanaged.linalg_svd_out_tttt
+
+linalg_svdvals_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+linalg_svdvals_ts = _cast2 Unmanaged.linalg_svdvals_ts
+
+linalg_svdvals_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_svdvals_t = _cast1 Unmanaged.linalg_svdvals_t
+
+linalg_svdvals_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+linalg_svdvals_out_tts = _cast3 Unmanaged.linalg_svdvals_out_tts
+
+linalg_svdvals_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_svdvals_out_tt = _cast2 Unmanaged.linalg_svdvals_out_tt
+
+linalg_cond_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+linalg_cond_ts = _cast2 Unmanaged.linalg_cond_ts
+
+linalg_cond_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_cond_t = _cast1 Unmanaged.linalg_cond_t
+
+linalg_cond_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+linalg_cond_out_tts = _cast3 Unmanaged.linalg_cond_out_tts
+
+linalg_cond_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_cond_out_tt = _cast2 Unmanaged.linalg_cond_out_tt
+
+linalg_pinv_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_tttb = _cast4 Unmanaged.linalg_pinv_tttb
+
+linalg_pinv_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_ttt = _cast3 Unmanaged.linalg_pinv_ttt
+
+linalg_pinv_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_tt = _cast2 Unmanaged.linalg_pinv_tt
+
+linalg_pinv_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_t = _cast1 Unmanaged.linalg_pinv_t
+
+linalg_pinv_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_ttttb = _cast5 Unmanaged.linalg_pinv_out_ttttb
+
+linalg_pinv_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_tttt = _cast4 Unmanaged.linalg_pinv_out_tttt
+
+linalg_pinv_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_ttt = _cast3 Unmanaged.linalg_pinv_out_ttt
+
+linalg_pinv_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_tt = _cast2 Unmanaged.linalg_pinv_out_tt
+
+linalg_pinv_tddb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_tddb = _cast4 Unmanaged.linalg_pinv_tddb
+
+linalg_pinv_tdd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_tdd = _cast3 Unmanaged.linalg_pinv_tdd
+
+linalg_pinv_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_td = _cast2 Unmanaged.linalg_pinv_td
+
+linalg_pinv_out_ttddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_ttddb = _cast5 Unmanaged.linalg_pinv_out_ttddb
+
+linalg_pinv_out_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_ttdd = _cast4 Unmanaged.linalg_pinv_out_ttdd
+
+linalg_pinv_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_ttd = _cast3 Unmanaged.linalg_pinv_out_ttd
+
+linalg_pinv_tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_tdb = _cast3 Unmanaged.linalg_pinv_tdb
+
+linalg_pinv_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_ttb = _cast3 Unmanaged.linalg_pinv_ttb
+
+linalg_pinv_out_ttdb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_ttdb = _cast4 Unmanaged.linalg_pinv_out_ttdb
+
+linalg_pinv_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_pinv_out_tttb = _cast4 Unmanaged.linalg_pinv_out_tttb
+
+_linalg_solve_ex_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_ttbb = _cast4 Unmanaged._linalg_solve_ex_ttbb
+
+_linalg_solve_ex_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_ttb = _cast3 Unmanaged._linalg_solve_ex_ttb
+
+_linalg_solve_ex_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_tt = _cast2 Unmanaged._linalg_solve_ex_tt
+
+_linalg_solve_ex_out_ttttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_out_ttttttbb = _cast8 Unmanaged._linalg_solve_ex_out_ttttttbb
+
+_linalg_solve_ex_out_ttttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_out_ttttttb = _cast7 Unmanaged._linalg_solve_ex_out_ttttttb
+
+_linalg_solve_ex_out_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_out_tttttt = _cast6 Unmanaged._linalg_solve_ex_out_tttttt
+
+linalg_solve_ex_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_ttbb = _cast4 Unmanaged.linalg_solve_ex_ttbb
+
+linalg_solve_ex_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_ttb = _cast3 Unmanaged.linalg_solve_ex_ttb
+
+linalg_solve_ex_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_tt = _cast2 Unmanaged.linalg_solve_ex_tt
+
+linalg_solve_ex_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_out_ttttbb = _cast6 Unmanaged.linalg_solve_ex_out_ttttbb
+
+linalg_solve_ex_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_out_ttttb = _cast5 Unmanaged.linalg_solve_ex_out_ttttb
+
+linalg_solve_ex_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_out_tttt = _cast4 Unmanaged.linalg_solve_ex_out_tttt
+
+linalg_solve_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_solve_ttb = _cast3 Unmanaged.linalg_solve_ttb
+
+linalg_solve_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_solve_tt = _cast2 Unmanaged.linalg_solve_tt
+
+linalg_solve_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_solve_out_tttb = _cast4 Unmanaged.linalg_solve_out_tttb
+
+linalg_solve_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_solve_out_ttt = _cast3 Unmanaged.linalg_solve_out_ttt
+
+linalg_tensorinv_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_tensorinv_tl = _cast2 Unmanaged.linalg_tensorinv_tl
+
+linalg_tensorinv_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_tensorinv_t = _cast1 Unmanaged.linalg_tensorinv_t
+
+linalg_tensorinv_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_tensorinv_out_ttl = _cast3 Unmanaged.linalg_tensorinv_out_ttl
+
+linalg_tensorinv_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_tensorinv_out_tt = _cast2 Unmanaged.linalg_tensorinv_out_tt
+
+linalg_tensorsolve_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+linalg_tensorsolve_ttl = _cast3 Unmanaged.linalg_tensorsolve_ttl
+
+linalg_tensorsolve_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_tensorsolve_tt = _cast2 Unmanaged.linalg_tensorsolve_tt
+
+linalg_tensorsolve_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+linalg_tensorsolve_out_tttl = _cast4 Unmanaged.linalg_tensorsolve_out_tttl
+
+linalg_tensorsolve_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_tensorsolve_out_ttt = _cast3 Unmanaged.linalg_tensorsolve_out_ttt
+
+linalg_qr_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_qr_ts = _cast2 Unmanaged.linalg_qr_ts
+
+linalg_qr_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_qr_t = _cast1 Unmanaged.linalg_qr_t
+
+linalg_qr_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_qr_out_ttts = _cast4 Unmanaged.linalg_qr_out_ttts
+
+linalg_qr_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+linalg_qr_out_ttt = _cast3 Unmanaged.linalg_qr_out_ttt
+
+linalg_matrix_power_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_power_tl = _cast2 Unmanaged.linalg_matrix_power_tl
+
+linalg_matrix_power_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_power_out_ttl = _cast3 Unmanaged.linalg_matrix_power_out_ttl
+
+linalg_matrix_rank_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_tttb = _cast4 Unmanaged.linalg_matrix_rank_tttb
+
+linalg_matrix_rank_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_ttt = _cast3 Unmanaged.linalg_matrix_rank_ttt
+
+linalg_matrix_rank_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_tt = _cast2 Unmanaged.linalg_matrix_rank_tt
+
+linalg_matrix_rank_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_t = _cast1 Unmanaged.linalg_matrix_rank_t
+
+linalg_matrix_rank_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_ttttb = _cast5 Unmanaged.linalg_matrix_rank_out_ttttb
+
+linalg_matrix_rank_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_tttt = _cast4 Unmanaged.linalg_matrix_rank_out_tttt
+
+linalg_matrix_rank_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_ttt = _cast3 Unmanaged.linalg_matrix_rank_out_ttt
+
+linalg_matrix_rank_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_tt = _cast2 Unmanaged.linalg_matrix_rank_out_tt
+
+linalg_matrix_rank_tddb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_tddb = _cast4 Unmanaged.linalg_matrix_rank_tddb
+
+linalg_matrix_rank_tdd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_tdd = _cast3 Unmanaged.linalg_matrix_rank_tdd
+
+linalg_matrix_rank_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_td = _cast2 Unmanaged.linalg_matrix_rank_td
+
+linalg_matrix_rank_out_ttddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_ttddb = _cast5 Unmanaged.linalg_matrix_rank_out_ttddb
+
+linalg_matrix_rank_out_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_ttdd = _cast4 Unmanaged.linalg_matrix_rank_out_ttdd
+
+linalg_matrix_rank_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_ttd = _cast3 Unmanaged.linalg_matrix_rank_out_ttd
+
+linalg_matrix_rank_tdb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_tdb = _cast3 Unmanaged.linalg_matrix_rank_tdb
+
+linalg_matrix_rank_out_ttdb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_ttdb = _cast4 Unmanaged.linalg_matrix_rank_out_ttdb
+
+linalg_matrix_rank_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_ttb = _cast3 Unmanaged.linalg_matrix_rank_ttb
+
+linalg_matrix_rank_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_rank_out_tttb = _cast4 Unmanaged.linalg_matrix_rank_out_tttb
+
+linalg_multi_dot_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+linalg_multi_dot_l = _cast1 Unmanaged.linalg_multi_dot_l
+
+linalg_multi_dot_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+linalg_multi_dot_out_tl = _cast2 Unmanaged.linalg_multi_dot_out_tl
+
+nested_to_padded_tensor_tdl
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+nested_to_padded_tensor_tdl = _cast3 Unmanaged.nested_to_padded_tensor_tdl
+
+nested_to_padded_tensor_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nested_to_padded_tensor_td = _cast2 Unmanaged.nested_to_padded_tensor_td
+
+_test_serialization_subcmul_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_test_serialization_subcmul_tts = _cast3 Unmanaged._test_serialization_subcmul_tts
+
+_test_serialization_subcmul_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_serialization_subcmul_tt = _cast2 Unmanaged._test_serialization_subcmul_tt
+
+_test_optional_intlist_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_test_optional_intlist_tl = _cast2 Unmanaged._test_optional_intlist_tl
+
+_test_optional_filled_intlist_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_test_optional_filled_intlist_tl = _cast2 Unmanaged._test_optional_filled_intlist_tl
+
+_test_optional_floatlist_ta
+  :: ForeignPtr Tensor
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_test_optional_floatlist_ta = _cast2 Unmanaged._test_optional_floatlist_ta
+
+_test_string_default_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+_test_string_default_tss = _cast3 Unmanaged._test_string_default_tss
+
+_test_string_default_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+_test_string_default_ts = _cast2 Unmanaged._test_string_default_ts
+
+_test_string_default_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_string_default_t = _cast1 Unmanaged._test_string_default_t
+
+_test_ambiguous_defaults_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_test_ambiguous_defaults_tll = _cast3 Unmanaged._test_ambiguous_defaults_tll
+
+_test_ambiguous_defaults_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_test_ambiguous_defaults_tl = _cast2 Unmanaged._test_ambiguous_defaults_tl
+
+_test_ambiguous_defaults_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_ambiguous_defaults_t = _cast1 Unmanaged._test_ambiguous_defaults_t
+
+_test_ambiguous_defaults_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+_test_ambiguous_defaults_tls = _cast3 Unmanaged._test_ambiguous_defaults_tls
+
+_test_warn_in_autograd_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_warn_in_autograd_t = _cast1 Unmanaged._test_warn_in_autograd_t
+
+_test_autograd_multiple_dispatch_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_autograd_multiple_dispatch_t = _cast1 Unmanaged._test_autograd_multiple_dispatch_t
+
+_test_autograd_multiple_dispatch_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_test_autograd_multiple_dispatch_tb = _cast2 Unmanaged._test_autograd_multiple_dispatch_tb
+
+_test_autograd_multiple_dispatch_view_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_autograd_multiple_dispatch_view_t = _cast1 Unmanaged._test_autograd_multiple_dispatch_view_t
+
+_test_autograd_multiple_dispatch_view_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_autograd_multiple_dispatch_view_copy_t = _cast1 Unmanaged._test_autograd_multiple_dispatch_view_copy_t
+
+segment_reduce_tstttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+segment_reduce_tstttlbs = _cast8 Unmanaged.segment_reduce_tstttlbs
+
+segment_reduce_tstttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+segment_reduce_tstttlb = _cast7 Unmanaged.segment_reduce_tstttlb
+
+segment_reduce_tstttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+segment_reduce_tstttl = _cast6 Unmanaged.segment_reduce_tstttl
+
+segment_reduce_tsttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+segment_reduce_tsttt = _cast5 Unmanaged.segment_reduce_tsttt
+
+segment_reduce_tstt
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+segment_reduce_tstt = _cast4 Unmanaged.segment_reduce_tstt
+
+segment_reduce_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+segment_reduce_tst = _cast3 Unmanaged.segment_reduce_tst
+
+segment_reduce_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+segment_reduce_ts = _cast2 Unmanaged.segment_reduce_ts
+
+_segment_reduce_backward_tttsttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_tttsttls = _cast8 Unmanaged._segment_reduce_backward_tttsttls
+
+_segment_reduce_backward_tttsttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_tttsttl = _cast7 Unmanaged._segment_reduce_backward_tttsttl
+
+_segment_reduce_backward_tttstt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_tttstt = _cast6 Unmanaged._segment_reduce_backward_tttstt
+
+_segment_reduce_backward_tttst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_tttst = _cast5 Unmanaged._segment_reduce_backward_tttst
+
+_segment_reduce_backward_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_ttts = _cast4 Unmanaged._segment_reduce_backward_ttts
+
+pad_sequence_lbd
+  :: ForeignPtr TensorList
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+pad_sequence_lbd = _cast3 Unmanaged.pad_sequence_lbd
+
+pad_sequence_lb
+  :: ForeignPtr TensorList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+pad_sequence_lb = _cast2 Unmanaged.pad_sequence_lb
+
+pad_sequence_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+pad_sequence_l = _cast1 Unmanaged.pad_sequence_l
+
+flatten_dense_tensors_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+flatten_dense_tensors_l = _cast1 Unmanaged.flatten_dense_tensors_l
+
+unflatten_dense_tensors_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+unflatten_dense_tensors_tl = _cast2 Unmanaged.unflatten_dense_tensors_tl
+
+_nested_tensor_from_tensor_list_lsLDb
+  :: ForeignPtr TensorList
+  -> ScalarType
+  -> Layout
+  -> DeviceType
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_lsLDb = _cast5 Unmanaged._nested_tensor_from_tensor_list_lsLDb
+
+_nested_tensor_from_tensor_list_lsLD
+  :: ForeignPtr TensorList
+  -> ScalarType
+  -> Layout
+  -> DeviceType
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_lsLD = _cast4 Unmanaged._nested_tensor_from_tensor_list_lsLD
+
+_nested_tensor_from_tensor_list_lsL
+  :: ForeignPtr TensorList
+  -> ScalarType
+  -> Layout
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_lsL = _cast3 Unmanaged._nested_tensor_from_tensor_list_lsL
+
+_nested_tensor_from_tensor_list_ls
+  :: ForeignPtr TensorList
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_ls = _cast2 Unmanaged._nested_tensor_from_tensor_list_ls
+
+_nested_tensor_from_tensor_list_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_l = _cast1 Unmanaged._nested_tensor_from_tensor_list_l
+
+_fw_primal_copy_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_fw_primal_copy_tl = _cast2 Unmanaged._fw_primal_copy_tl
+
+_make_dual_copy_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_make_dual_copy_ttl = _cast3 Unmanaged._make_dual_copy_ttl
+
+view_as_real_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+view_as_real_copy_t = _cast1 Unmanaged.view_as_real_copy_t
+
+view_as_complex_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+view_as_complex_copy_t = _cast1 Unmanaged.view_as_complex_copy_t
+
+_conj_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_conj_copy_t = _cast1 Unmanaged._conj_copy_t
+
+_neg_view_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_neg_view_copy_t = _cast1 Unmanaged._neg_view_copy_t
+
+as_strided_copy_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+as_strided_copy_tlll = _cast4 Unmanaged.as_strided_copy_tlll
+
+as_strided_copy_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+as_strided_copy_tll = _cast3 Unmanaged.as_strided_copy_tll
+
+_sparse_broadcast_to_copy_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_broadcast_to_copy_tl = _cast2 Unmanaged._sparse_broadcast_to_copy_tl
+
+diagonal_copy_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_copy_tlll = _cast4 Unmanaged.diagonal_copy_tlll
+
+diagonal_copy_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_copy_tll = _cast3 Unmanaged.diagonal_copy_tll
+
+diagonal_copy_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_copy_tl = _cast2 Unmanaged.diagonal_copy_tl
+
+diagonal_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diagonal_copy_t = _cast1 Unmanaged.diagonal_copy_t
+
+expand_copy_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+expand_copy_tlb = _cast3 Unmanaged.expand_copy_tlb
+
+expand_copy_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+expand_copy_tl = _cast2 Unmanaged.expand_copy_tl
+
+permute_copy_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+permute_copy_tl = _cast2 Unmanaged.permute_copy_tl
+
+_reshape_alias_copy_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_reshape_alias_copy_tll = _cast3 Unmanaged._reshape_alias_copy_tll
+
+select_copy_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+select_copy_tll = _cast3 Unmanaged.select_copy_tll
+
+detach_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+detach_copy_t = _cast1 Unmanaged.detach_copy_t
+
+slice_copy_tllll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_copy_tllll = _cast5 Unmanaged.slice_copy_tllll
+
+slice_copy_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_copy_tlll = _cast4 Unmanaged.slice_copy_tlll
+
+slice_copy_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_copy_tll = _cast3 Unmanaged.slice_copy_tll
+
+slice_copy_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_copy_tl = _cast2 Unmanaged.slice_copy_tl
+
+slice_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slice_copy_t = _cast1 Unmanaged.slice_copy_t
+
+split_copy_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+split_copy_tll = _cast3 Unmanaged.split_copy_tll
+
+split_copy_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+split_copy_tl = _cast2 Unmanaged.split_copy_tl
+
+split_with_sizes_copy_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+split_with_sizes_copy_tll = _cast3 Unmanaged.split_with_sizes_copy_tll
+
+split_with_sizes_copy_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr TensorList)
+split_with_sizes_copy_tl = _cast2 Unmanaged.split_with_sizes_copy_tl
+
+squeeze_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+squeeze_copy_t = _cast1 Unmanaged.squeeze_copy_t
+
+squeeze_copy_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+squeeze_copy_tl = _cast2 Unmanaged.squeeze_copy_tl
+
+t_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+t_copy_t = _cast1 Unmanaged.t_copy_t
+
+transpose_copy_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+transpose_copy_tll = _cast3 Unmanaged.transpose_copy_tll
+
+unsqueeze_copy_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+unsqueeze_copy_tl = _cast2 Unmanaged.unsqueeze_copy_tl
+
+_indices_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_indices_copy_t = _cast1 Unmanaged._indices_copy_t
+
+_values_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_values_copy_t = _cast1 Unmanaged._values_copy_t
+
+indices_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+indices_copy_t = _cast1 Unmanaged.indices_copy_t
+
+values_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+values_copy_t = _cast1 Unmanaged.values_copy_t
+
+crow_indices_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+crow_indices_copy_t = _cast1 Unmanaged.crow_indices_copy_t
+
+col_indices_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+col_indices_copy_t = _cast1 Unmanaged.col_indices_copy_t
+
+ccol_indices_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ccol_indices_copy_t = _cast1 Unmanaged.ccol_indices_copy_t
+
+row_indices_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+row_indices_copy_t = _cast1 Unmanaged.row_indices_copy_t
+
+unbind_copy_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+unbind_copy_tl = _cast2 Unmanaged.unbind_copy_tl
+
+unbind_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+unbind_copy_t = _cast1 Unmanaged.unbind_copy_t
+
+unbind_copy_out_ltl
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (())
+unbind_copy_out_ltl = _cast3 Unmanaged.unbind_copy_out_ltl
+
+unbind_copy_out_lt
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (())
+unbind_copy_out_lt = _cast2 Unmanaged.unbind_copy_out_lt
+
+split_copy_out_ltll
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (())
+split_copy_out_ltll = _cast4 Unmanaged.split_copy_out_ltll
+
+split_copy_out_ltl
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (())
+split_copy_out_ltl = _cast3 Unmanaged.split_copy_out_ltl
+
+split_with_sizes_copy_out_ltll
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (())
+split_with_sizes_copy_out_ltll = _cast4 Unmanaged.split_with_sizes_copy_out_ltll
+
+split_with_sizes_copy_out_ltl
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+split_with_sizes_copy_out_ltl = _cast3 Unmanaged.split_with_sizes_copy_out_ltl
+
+view_copy_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+view_copy_tl = _cast2 Unmanaged.view_copy_tl
+
+view_copy_ts
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+view_copy_ts = _cast2 Unmanaged.view_copy_ts
+
+unfold_copy_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+unfold_copy_tlll = _cast4 Unmanaged.unfold_copy_tlll
+
+alias_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+alias_copy_t = _cast1 Unmanaged.alias_copy_t
+
+_nested_tensor_softmax_with_shape_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_softmax_with_shape_tt = _cast2 Unmanaged._nested_tensor_softmax_with_shape_tt
+
+_transformer_encoder_layer_fwd_tllttttbbdtttttttttl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_transformer_encoder_layer_fwd_tllttttbbdtttttttttl = _cast20 Unmanaged._transformer_encoder_layer_fwd_tllttttbbdtttttttttl
+
+_transformer_encoder_layer_fwd_tllttttbbdttttttttt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_transformer_encoder_layer_fwd_tllttttbbdttttttttt = _cast19 Unmanaged._transformer_encoder_layer_fwd_tllttttbbdttttttttt
+
+_transformer_encoder_layer_fwd_tllttttbbdtttttttt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_transformer_encoder_layer_fwd_tllttttbbdtttttttt = _cast18 Unmanaged._transformer_encoder_layer_fwd_tllttttbbdtttttttt
+
+_native_multi_head_attention_tttlltttttbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttlltttttbbl = _cast13 Unmanaged._native_multi_head_attention_tttlltttttbbl
+
+_native_multi_head_attention_tttlltttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttlltttttbb = _cast12 Unmanaged._native_multi_head_attention_tttlltttttbb
+
+_native_multi_head_attention_tttlltttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttlltttttb = _cast11 Unmanaged._native_multi_head_attention_tttlltttttb
+
+_native_multi_head_attention_tttllttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttllttttt = _cast10 Unmanaged._native_multi_head_attention_tttllttttt
+
+_native_multi_head_attention_tttlltttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttlltttt = _cast9 Unmanaged._native_multi_head_attention_tttlltttt
+
+scaled_dot_product_attention_ttttdb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+scaled_dot_product_attention_ttttdb = _cast6 Unmanaged.scaled_dot_product_attention_ttttdb
+
+scaled_dot_product_attention_ttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+scaled_dot_product_attention_ttttd = _cast5 Unmanaged.scaled_dot_product_attention_ttttd
+
+scaled_dot_product_attention_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+scaled_dot_product_attention_tttt = _cast4 Unmanaged.scaled_dot_product_attention_tttt
+
+scaled_dot_product_attention_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+scaled_dot_product_attention_ttt = _cast3 Unmanaged.scaled_dot_product_attention_ttt
+
+_fused_sdp_choice_ttttdb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Int64)
+_fused_sdp_choice_ttttdb = _cast6 Unmanaged._fused_sdp_choice_ttttdb
+
+_fused_sdp_choice_ttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (Int64)
+_fused_sdp_choice_ttttd = _cast5 Unmanaged._fused_sdp_choice_ttttd
+
+_fused_sdp_choice_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (Int64)
+_fused_sdp_choice_tttt = _cast4 Unmanaged._fused_sdp_choice_tttt
+
+_fused_sdp_choice_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (Int64)
+_fused_sdp_choice_ttt = _cast3 Unmanaged._fused_sdp_choice_ttt
+
+_triton_scaled_dot_attention_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_triton_scaled_dot_attention_tttd = _cast4 Unmanaged._triton_scaled_dot_attention_tttd
+
+_triton_scaled_dot_attention_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_triton_scaled_dot_attention_ttt = _cast3 Unmanaged._triton_scaled_dot_attention_ttt
+
+_triton_multi_head_attention_tttllttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_triton_multi_head_attention_tttllttttt = _cast10 Unmanaged._triton_multi_head_attention_tttllttttt
+
+_triton_multi_head_attention_tttlltttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_triton_multi_head_attention_tttlltttt = _cast9 Unmanaged._triton_multi_head_attention_tttlltttt
+
+special_airy_ai_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_airy_ai_t = _cast1 Unmanaged.special_airy_ai_t
+
+special_airy_ai_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_airy_ai_out_tt = _cast2 Unmanaged.special_airy_ai_out_tt
+
+special_bessel_j0_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_bessel_j0_t = _cast1 Unmanaged.special_bessel_j0_t
+
+special_bessel_j0_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_bessel_j0_out_tt = _cast2 Unmanaged.special_bessel_j0_out_tt
+
+special_bessel_j1_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_bessel_j1_t = _cast1 Unmanaged.special_bessel_j1_t
+
+special_bessel_j1_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_bessel_j1_out_tt = _cast2 Unmanaged.special_bessel_j1_out_tt
+
+special_bessel_y0_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_bessel_y0_t = _cast1 Unmanaged.special_bessel_y0_t
+
+special_bessel_y0_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_bessel_y0_out_tt = _cast2 Unmanaged.special_bessel_y0_out_tt
+
+special_bessel_y1_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_bessel_y1_t = _cast1 Unmanaged.special_bessel_y1_t
+
+special_bessel_y1_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_bessel_y1_out_tt = _cast2 Unmanaged.special_bessel_y1_out_tt
+
+special_chebyshev_polynomial_t_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_t_tt = _cast2 Unmanaged.special_chebyshev_polynomial_t_tt
+
+special_chebyshev_polynomial_t_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_t_st = _cast2 Unmanaged.special_chebyshev_polynomial_t_st
+
+special_chebyshev_polynomial_t_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_t_ts = _cast2 Unmanaged.special_chebyshev_polynomial_t_ts
+
+special_chebyshev_polynomial_t_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_t_out_ttt = _cast3 Unmanaged.special_chebyshev_polynomial_t_out_ttt
+
+special_chebyshev_polynomial_t_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_t_out_tst = _cast3 Unmanaged.special_chebyshev_polynomial_t_out_tst
+
+special_chebyshev_polynomial_t_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_t_out_tts = _cast3 Unmanaged.special_chebyshev_polynomial_t_out_tts
+
+special_chebyshev_polynomial_u_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_u_tt = _cast2 Unmanaged.special_chebyshev_polynomial_u_tt
+
+special_chebyshev_polynomial_u_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_u_st = _cast2 Unmanaged.special_chebyshev_polynomial_u_st
+
+special_chebyshev_polynomial_u_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_u_ts = _cast2 Unmanaged.special_chebyshev_polynomial_u_ts
+
+special_chebyshev_polynomial_u_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_u_out_ttt = _cast3 Unmanaged.special_chebyshev_polynomial_u_out_ttt
+
+special_chebyshev_polynomial_u_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_u_out_tst = _cast3 Unmanaged.special_chebyshev_polynomial_u_out_tst
+
+special_chebyshev_polynomial_u_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_u_out_tts = _cast3 Unmanaged.special_chebyshev_polynomial_u_out_tts
+
+special_chebyshev_polynomial_v_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_v_tt = _cast2 Unmanaged.special_chebyshev_polynomial_v_tt
+
+special_chebyshev_polynomial_v_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_v_st = _cast2 Unmanaged.special_chebyshev_polynomial_v_st
+
+special_chebyshev_polynomial_v_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_v_ts = _cast2 Unmanaged.special_chebyshev_polynomial_v_ts
+
+special_chebyshev_polynomial_v_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_v_out_ttt = _cast3 Unmanaged.special_chebyshev_polynomial_v_out_ttt
+
+special_chebyshev_polynomial_v_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_v_out_tst = _cast3 Unmanaged.special_chebyshev_polynomial_v_out_tst
+
+special_chebyshev_polynomial_v_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_v_out_tts = _cast3 Unmanaged.special_chebyshev_polynomial_v_out_tts
+
+special_chebyshev_polynomial_w_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_w_tt = _cast2 Unmanaged.special_chebyshev_polynomial_w_tt
+
+special_chebyshev_polynomial_w_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_w_st = _cast2 Unmanaged.special_chebyshev_polynomial_w_st
+
+special_chebyshev_polynomial_w_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_w_ts = _cast2 Unmanaged.special_chebyshev_polynomial_w_ts
+
+special_chebyshev_polynomial_w_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_w_out_ttt = _cast3 Unmanaged.special_chebyshev_polynomial_w_out_ttt
+
+special_chebyshev_polynomial_w_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_w_out_tst = _cast3 Unmanaged.special_chebyshev_polynomial_w_out_tst
+
+special_chebyshev_polynomial_w_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_chebyshev_polynomial_w_out_tts = _cast3 Unmanaged.special_chebyshev_polynomial_w_out_tts
+
diff --git a/src/Torch/Internal/Managed/Native/Native13.hs b/src/Torch/Internal/Managed/Native/Native13.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native13.hs
@@ -0,0 +1,2714 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native13 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native13 as Unmanaged
+
+
+special_hermite_polynomial_h_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_h_tt = _cast2 Unmanaged.special_hermite_polynomial_h_tt
+
+special_hermite_polynomial_h_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_h_st = _cast2 Unmanaged.special_hermite_polynomial_h_st
+
+special_hermite_polynomial_h_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_h_ts = _cast2 Unmanaged.special_hermite_polynomial_h_ts
+
+special_hermite_polynomial_h_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_h_out_ttt = _cast3 Unmanaged.special_hermite_polynomial_h_out_ttt
+
+special_hermite_polynomial_h_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_h_out_tst = _cast3 Unmanaged.special_hermite_polynomial_h_out_tst
+
+special_hermite_polynomial_h_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_h_out_tts = _cast3 Unmanaged.special_hermite_polynomial_h_out_tts
+
+special_hermite_polynomial_he_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_he_tt = _cast2 Unmanaged.special_hermite_polynomial_he_tt
+
+special_hermite_polynomial_he_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_he_st = _cast2 Unmanaged.special_hermite_polynomial_he_st
+
+special_hermite_polynomial_he_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_he_ts = _cast2 Unmanaged.special_hermite_polynomial_he_ts
+
+special_hermite_polynomial_he_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_he_out_ttt = _cast3 Unmanaged.special_hermite_polynomial_he_out_ttt
+
+special_hermite_polynomial_he_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_he_out_tst = _cast3 Unmanaged.special_hermite_polynomial_he_out_tst
+
+special_hermite_polynomial_he_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_hermite_polynomial_he_out_tts = _cast3 Unmanaged.special_hermite_polynomial_he_out_tts
+
+special_laguerre_polynomial_l_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_laguerre_polynomial_l_tt = _cast2 Unmanaged.special_laguerre_polynomial_l_tt
+
+special_laguerre_polynomial_l_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_laguerre_polynomial_l_st = _cast2 Unmanaged.special_laguerre_polynomial_l_st
+
+special_laguerre_polynomial_l_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_laguerre_polynomial_l_ts = _cast2 Unmanaged.special_laguerre_polynomial_l_ts
+
+special_laguerre_polynomial_l_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_laguerre_polynomial_l_out_ttt = _cast3 Unmanaged.special_laguerre_polynomial_l_out_ttt
+
+special_laguerre_polynomial_l_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_laguerre_polynomial_l_out_tst = _cast3 Unmanaged.special_laguerre_polynomial_l_out_tst
+
+special_laguerre_polynomial_l_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_laguerre_polynomial_l_out_tts = _cast3 Unmanaged.special_laguerre_polynomial_l_out_tts
+
+special_legendre_polynomial_p_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_legendre_polynomial_p_tt = _cast2 Unmanaged.special_legendre_polynomial_p_tt
+
+special_legendre_polynomial_p_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_legendre_polynomial_p_st = _cast2 Unmanaged.special_legendre_polynomial_p_st
+
+special_legendre_polynomial_p_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_legendre_polynomial_p_ts = _cast2 Unmanaged.special_legendre_polynomial_p_ts
+
+special_legendre_polynomial_p_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_legendre_polynomial_p_out_ttt = _cast3 Unmanaged.special_legendre_polynomial_p_out_ttt
+
+special_legendre_polynomial_p_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_legendre_polynomial_p_out_tst = _cast3 Unmanaged.special_legendre_polynomial_p_out_tst
+
+special_legendre_polynomial_p_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_legendre_polynomial_p_out_tts = _cast3 Unmanaged.special_legendre_polynomial_p_out_tts
+
+special_modified_bessel_i0_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_modified_bessel_i0_t = _cast1 Unmanaged.special_modified_bessel_i0_t
+
+special_modified_bessel_i0_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_modified_bessel_i0_out_tt = _cast2 Unmanaged.special_modified_bessel_i0_out_tt
+
+special_modified_bessel_i1_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_modified_bessel_i1_t = _cast1 Unmanaged.special_modified_bessel_i1_t
+
+special_modified_bessel_i1_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_modified_bessel_i1_out_tt = _cast2 Unmanaged.special_modified_bessel_i1_out_tt
+
+special_modified_bessel_k0_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_modified_bessel_k0_t = _cast1 Unmanaged.special_modified_bessel_k0_t
+
+special_modified_bessel_k0_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_modified_bessel_k0_out_tt = _cast2 Unmanaged.special_modified_bessel_k0_out_tt
+
+special_modified_bessel_k1_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_modified_bessel_k1_t = _cast1 Unmanaged.special_modified_bessel_k1_t
+
+special_modified_bessel_k1_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_modified_bessel_k1_out_tt = _cast2 Unmanaged.special_modified_bessel_k1_out_tt
+
+special_scaled_modified_bessel_k0_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_scaled_modified_bessel_k0_t = _cast1 Unmanaged.special_scaled_modified_bessel_k0_t
+
+special_scaled_modified_bessel_k0_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_scaled_modified_bessel_k0_out_tt = _cast2 Unmanaged.special_scaled_modified_bessel_k0_out_tt
+
+special_scaled_modified_bessel_k1_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_scaled_modified_bessel_k1_t = _cast1 Unmanaged.special_scaled_modified_bessel_k1_t
+
+special_scaled_modified_bessel_k1_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_scaled_modified_bessel_k1_out_tt = _cast2 Unmanaged.special_scaled_modified_bessel_k1_out_tt
+
+special_shifted_chebyshev_polynomial_t_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_t_tt = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_t_tt
+
+special_shifted_chebyshev_polynomial_t_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_t_st = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_t_st
+
+special_shifted_chebyshev_polynomial_t_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_t_ts = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_t_ts
+
+special_shifted_chebyshev_polynomial_t_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_t_out_ttt = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_t_out_ttt
+
+special_shifted_chebyshev_polynomial_t_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_t_out_tst = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_t_out_tst
+
+special_shifted_chebyshev_polynomial_t_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_t_out_tts = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_t_out_tts
+
+special_shifted_chebyshev_polynomial_u_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_u_tt = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_u_tt
+
+special_shifted_chebyshev_polynomial_u_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_u_st = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_u_st
+
+special_shifted_chebyshev_polynomial_u_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_u_ts = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_u_ts
+
+special_shifted_chebyshev_polynomial_u_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_u_out_ttt = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_u_out_ttt
+
+special_shifted_chebyshev_polynomial_u_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_u_out_tst = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_u_out_tst
+
+special_shifted_chebyshev_polynomial_u_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_u_out_tts = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_u_out_tts
+
+special_shifted_chebyshev_polynomial_v_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_v_tt = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_v_tt
+
+special_shifted_chebyshev_polynomial_v_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_v_st = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_v_st
+
+special_shifted_chebyshev_polynomial_v_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_v_ts = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_v_ts
+
+special_shifted_chebyshev_polynomial_v_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_v_out_ttt = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_v_out_ttt
+
+special_shifted_chebyshev_polynomial_v_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_v_out_tst = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_v_out_tst
+
+special_shifted_chebyshev_polynomial_v_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_v_out_tts = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_v_out_tts
+
+special_shifted_chebyshev_polynomial_w_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_w_tt = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_w_tt
+
+special_shifted_chebyshev_polynomial_w_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_w_st = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_w_st
+
+special_shifted_chebyshev_polynomial_w_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_w_ts = _cast2 Unmanaged.special_shifted_chebyshev_polynomial_w_ts
+
+special_shifted_chebyshev_polynomial_w_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_w_out_ttt = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_w_out_ttt
+
+special_shifted_chebyshev_polynomial_w_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_w_out_tst = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_w_out_tst
+
+special_shifted_chebyshev_polynomial_w_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+special_shifted_chebyshev_polynomial_w_out_tts = _cast3 Unmanaged.special_shifted_chebyshev_polynomial_w_out_tts
+
+special_spherical_bessel_j0_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_spherical_bessel_j0_t = _cast1 Unmanaged.special_spherical_bessel_j0_t
+
+special_spherical_bessel_j0_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+special_spherical_bessel_j0_out_tt = _cast2 Unmanaged.special_spherical_bessel_j0_out_tt
+
+_foobar_tbbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_foobar_tbbb = _cast4 Unmanaged._foobar_tbbb
+
+_foobar_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_foobar_tbb = _cast3 Unmanaged._foobar_tbb
+
+_foobar_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_foobar_tb = _cast2 Unmanaged._foobar_tb
+
+_foobar_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_foobar_t = _cast1 Unmanaged._foobar_t
+
+_fused_adam__lllllldddddbbtt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+_fused_adam__lllllldddddbbtt = _cast15 Unmanaged._fused_adam__lllllldddddbbtt
+
+_fused_adam__lllllldddddbbt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (())
+_fused_adam__lllllldddddbbt = _cast14 Unmanaged._fused_adam__lllllldddddbbt
+
+_fused_adam__lllllldddddbb
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (())
+_fused_adam__lllllldddddbb = _cast13 Unmanaged._fused_adam__lllllldddddbb
+
+_fused_adamw__lllllldddddbbtt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+_fused_adamw__lllllldddddbbtt = _cast15 Unmanaged._fused_adamw__lllllldddddbbtt
+
+_fused_adamw__lllllldddddbbt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (())
+_fused_adamw__lllllldddddbbt = _cast14 Unmanaged._fused_adamw__lllllldddddbbt
+
+_fused_adamw__lllllldddddbb
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (())
+_fused_adamw__lllllldddddbb = _cast13 Unmanaged._fused_adamw__lllllldddddbb
+
+_new_zeros_with_same_feature_meta_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_new_zeros_with_same_feature_meta_out_tttl = _cast4 Unmanaged._new_zeros_with_same_feature_meta_out_tttl
+
+_new_zeros_with_same_feature_meta_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_new_zeros_with_same_feature_meta_out_ttt = _cast3 Unmanaged._new_zeros_with_same_feature_meta_out_ttt
+
+_cudnn_ctc_loss_out_ttttlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_cudnn_ctc_loss_out_ttttlllbb = _cast9 Unmanaged._cudnn_ctc_loss_out_ttttlllbb
+
+_cudnn_rnn_flatten_weight_out_tlllllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cudnn_rnn_flatten_weight_out_tlllllllbb = _cast10 Unmanaged._cudnn_rnn_flatten_weight_out_tlllllllbb
+
+_cudnn_rnn_out_ttttttlltttllllbdbblt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_cudnn_rnn_out_ttttttlltttllllbdbblt = _cast21 Unmanaged._cudnn_rnn_out_ttttttlltttllllbdbblt
+
+_cudnn_rnn_backward_out_tttltlltttttttllllbdbbltta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,4))
+  -> IO (())
+_cudnn_rnn_backward_out_tttltlltttttttllllbdbbltta = _cast26 Unmanaged._cudnn_rnn_backward_out_tttltlltttttttllllbdbbltta
+
+_cudnn_init_dropout_state_out_tdbl
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_cudnn_init_dropout_state_out_tdbl = _cast4 Unmanaged._cudnn_init_dropout_state_out_tdbl
+
+_fused_dropout_out_tttdG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_dropout_out_tttdG = _cast5 Unmanaged._fused_dropout_out_tttdG
+
+_fused_dropout_out_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_dropout_out_tttd = _cast4 Unmanaged._fused_dropout_out_tttd
+
+_masked_scale_out_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_masked_scale_out_tttd = _cast4 Unmanaged._masked_scale_out_tttd
+
+native_dropout_out_tttdb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+native_dropout_out_tttdb = _cast5 Unmanaged.native_dropout_out_tttdb
+
+native_dropout_backward_out_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+native_dropout_backward_out_tttd = _cast4 Unmanaged.native_dropout_backward_out_tttd
+
+_conj_physical_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_conj_physical_out_tt = _cast2 Unmanaged._conj_physical_out_tt
+
+_add_relu_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu_out_ttss = _cast4 Unmanaged._add_relu_out_ttss
+
+_add_relu_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_add_relu_out_tts = _cast3 Unmanaged._add_relu_out_tts
+
+add_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+add_out_ttss = _cast4 Unmanaged.add_out_ttss
+
+add_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+add_out_tts = _cast3 Unmanaged.add_out_tts
+
+affine_grid_generator_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+affine_grid_generator_out_ttlb = _cast4 Unmanaged.affine_grid_generator_out_ttlb
+
+bartlett_window_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+bartlett_window_out_tl = _cast2 Unmanaged.bartlett_window_out_tl
+
+bartlett_window_out_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bartlett_window_out_tlb = _cast3 Unmanaged.bartlett_window_out_tlb
+
+quantized_batch_norm_out_ttttttddl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+quantized_batch_norm_out_ttttttddl = _cast9 Unmanaged.quantized_batch_norm_out_ttttttddl
+
+bernoulli_out_tttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+bernoulli_out_tttG = _cast4 Unmanaged.bernoulli_out_tttG
+
+bernoulli_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bernoulli_out_ttt = _cast3 Unmanaged.bernoulli_out_ttt
+
+bernoulli_ttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+bernoulli_ttG = _cast3 Unmanaged.bernoulli_ttG
+
+bernoulli_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bernoulli_tt = _cast2 Unmanaged.bernoulli_tt
+
+bernoulli_out_ttdG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+bernoulli_out_ttdG = _cast4 Unmanaged.bernoulli_out_ttdG
+
+bernoulli_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+bernoulli_out_ttd = _cast3 Unmanaged.bernoulli_out_ttd
+
+-- bernoulli_out_tt
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr Tensor
+--   -> IO (ForeignPtr Tensor)
+-- bernoulli_out_tt = _cast2 Unmanaged.bernoulli_out_tt
+
+binary_cross_entropy_with_logits_out_tttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_with_logits_out_tttttl = _cast6 Unmanaged.binary_cross_entropy_with_logits_out_tttttl
+
+binary_cross_entropy_with_logits_out_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_with_logits_out_ttttt = _cast5 Unmanaged.binary_cross_entropy_with_logits_out_ttttt
+
+binary_cross_entropy_with_logits_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_with_logits_out_tttt = _cast4 Unmanaged.binary_cross_entropy_with_logits_out_tttt
+
+binary_cross_entropy_with_logits_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binary_cross_entropy_with_logits_out_ttt = _cast3 Unmanaged.binary_cross_entropy_with_logits_out_ttt
+
+bincount_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+bincount_out_tttl = _cast4 Unmanaged.bincount_out_tttl
+
+bincount_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bincount_out_ttt = _cast3 Unmanaged.bincount_out_ttt
+
+bincount_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bincount_out_tt = _cast2 Unmanaged.bincount_out_tt
+
+blackman_window_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+blackman_window_out_tl = _cast2 Unmanaged.blackman_window_out_tl
+
+blackman_window_out_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+blackman_window_out_tlb = _cast3 Unmanaged.blackman_window_out_tlb
+
+block_diag_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+block_diag_out_tl = _cast2 Unmanaged.block_diag_out_tl
+
+constant_pad_nd_out_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+constant_pad_nd_out_ttls = _cast4 Unmanaged.constant_pad_nd_out_ttls
+
+constant_pad_nd_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+constant_pad_nd_out_ttl = _cast3 Unmanaged.constant_pad_nd_out_ttl
+
+convolution_out_ttttlllbll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+convolution_out_ttttlllbll = _cast10 Unmanaged.convolution_out_ttttlllbll
+
+convolution_backward_out_ttttttllllblla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+convolution_backward_out_ttttttllllblla = _cast14 Unmanaged.convolution_backward_out_ttttttllllblla
+
+convolution_overrideable_out_ttttlllbll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+convolution_overrideable_out_ttttlllbll = _cast10 Unmanaged.convolution_overrideable_out_ttttlllbll
+
+convolution_backward_overrideable_out_ttttttlllblla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+convolution_backward_overrideable_out_ttttttlllblla = _cast13 Unmanaged.convolution_backward_overrideable_out_ttttttlllblla
+
+_convolution_out_ttttlllbllbbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convolution_out_ttttlllbllbbbb = _cast14 Unmanaged._convolution_out_ttttlllbllbbbb
+
+conv_tbc_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+conv_tbc_out_ttttl = _cast5 Unmanaged.conv_tbc_out_ttttl
+
+conv_tbc_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+conv_tbc_out_tttt = _cast4 Unmanaged.conv_tbc_out_tttt
+
+copy_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+copy_out_tttb = _cast4 Unmanaged.copy_out_tttb
+
+copy_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+copy_out_ttt = _cast3 Unmanaged.copy_out_ttt
+
+_copy_from_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_copy_from_out_tttb = _cast4 Unmanaged._copy_from_out_tttb
+
+_copy_from_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_copy_from_out_ttt = _cast3 Unmanaged._copy_from_out_ttt
+
+_copy_from_and_resize_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_copy_from_and_resize_out_ttt = _cast3 Unmanaged._copy_from_and_resize_out_ttt
+
+count_nonzero_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+count_nonzero_out_ttl = _cast3 Unmanaged.count_nonzero_out_ttl
+
+count_nonzero_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+count_nonzero_out_tt = _cast2 Unmanaged.count_nonzero_out_tt
+
+cudnn_affine_grid_generator_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cudnn_affine_grid_generator_out_ttllll = _cast6 Unmanaged.cudnn_affine_grid_generator_out_ttllll
+
+cudnn_affine_grid_generator_backward_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cudnn_affine_grid_generator_backward_out_ttllll = _cast6 Unmanaged.cudnn_affine_grid_generator_backward_out_ttllll
+
+cudnn_batch_norm_out_tttttttttbdd
+  :: ForeignPtr Tensor
+  -> 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,Tensor)))
+cudnn_batch_norm_out_tttttttttbdd = _cast12 Unmanaged.cudnn_batch_norm_out_tttttttttbdd
+
+cudnn_batch_norm_backward_out_ttttttttttdt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+cudnn_batch_norm_backward_out_ttttttttttdt = _cast12 Unmanaged.cudnn_batch_norm_backward_out_ttttttttttdt
+
+cudnn_convolution_out_tttllllbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_out_tttllllbbb = _cast10 Unmanaged.cudnn_convolution_out_tttllllbbb
+
+cudnn_convolution_transpose_out_tttlllllbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_transpose_out_tttlllllbbb = _cast11 Unmanaged.cudnn_convolution_transpose_out_tttlllllbbb
+
+_mps_convolution_transpose_out_tttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_mps_convolution_transpose_out_tttlllll = _cast8 Unmanaged._mps_convolution_transpose_out_tttlllll
+
+mps_convolution_transpose_backward_out_tttttllllla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mps_convolution_transpose_backward_out_tttttllllla = _cast11 Unmanaged.mps_convolution_transpose_backward_out_tttttllllla
+
+cudnn_convolution_relu_out_ttttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_relu_out_ttttllll = _cast8 Unmanaged.cudnn_convolution_relu_out_ttttllll
+
+cudnn_convolution_add_relu_out_ttttstllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cudnn_convolution_add_relu_out_ttttstllll = _cast10 Unmanaged.cudnn_convolution_add_relu_out_ttttstllll
+
+cudnn_grid_sampler_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cudnn_grid_sampler_out_ttt = _cast3 Unmanaged.cudnn_grid_sampler_out_ttt
+
+cudnn_grid_sampler_backward_out_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+cudnn_grid_sampler_backward_out_ttttt = _cast5 Unmanaged.cudnn_grid_sampler_backward_out_ttttt
+
+_ctc_loss_out_ttttlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttlllb = _cast8 Unmanaged._ctc_loss_out_ttttlllb
+
+_ctc_loss_out_ttttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttlll = _cast7 Unmanaged._ctc_loss_out_ttttlll
+
+_ctc_loss_out_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttll = _cast6 Unmanaged._ctc_loss_out_ttttll
+
+_ctc_loss_out_ttttttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttttlb = _cast8 Unmanaged._ctc_loss_out_ttttttlb
+
+_ctc_loss_out_ttttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttttl = _cast7 Unmanaged._ctc_loss_out_ttttttl
+
+_ctc_loss_out_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_tttttt = _cast6 Unmanaged._ctc_loss_out_tttttt
+
+_ctc_loss_backward_out_ttttllttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_ctc_loss_backward_out_ttttllttlb = _cast10 Unmanaged._ctc_loss_backward_out_ttttllttlb
+
+_ctc_loss_backward_out_ttttllttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_ctc_loss_backward_out_ttttllttl = _cast9 Unmanaged._ctc_loss_backward_out_ttttllttl
+
+diag_embed_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diag_embed_out_ttlll = _cast5 Unmanaged.diag_embed_out_ttlll
+
+diag_embed_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diag_embed_out_ttll = _cast4 Unmanaged.diag_embed_out_ttll
+
+diag_embed_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diag_embed_out_ttl = _cast3 Unmanaged.diag_embed_out_ttl
+
+diag_embed_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diag_embed_out_tt = _cast2 Unmanaged.diag_embed_out_tt
+
+diagonal_backward_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_backward_out_ttllll = _cast6 Unmanaged.diagonal_backward_out_ttllll
+
+div_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+div_out_tts = _cast3 Unmanaged.div_out_tts
+
+div_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+div_out_ttss = _cast4 Unmanaged.div_out_ttss
+
+embedding_out_tttlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+embedding_out_tttlbb = _cast6 Unmanaged.embedding_out_tttlbb
+
+embedding_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+embedding_out_tttlb = _cast5 Unmanaged.embedding_out_tttlb
+
+embedding_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+embedding_out_tttl = _cast4 Unmanaged.embedding_out_tttl
+
+embedding_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+embedding_out_ttt = _cast3 Unmanaged.embedding_out_ttt
+
+embedding_dense_backward_out_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+embedding_dense_backward_out_tttllb = _cast6 Unmanaged.embedding_dense_backward_out_tttllb
+
+embedding_renorm_out_tttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+embedding_renorm_out_tttdd = _cast5 Unmanaged.embedding_renorm_out_tttdd
+
+embedding_renorm_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+embedding_renorm_ttdd = _cast4 Unmanaged.embedding_renorm_ttdd
+
+_embedding_bag_forward_only_out_tttttttblbtbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttblbtbl = _cast13 Unmanaged._embedding_bag_forward_only_out_tttttttblbtbl
+
+_embedding_bag_forward_only_out_tttttttblbtb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttblbtb = _cast12 Unmanaged._embedding_bag_forward_only_out_tttttttblbtb
+
+_embedding_bag_forward_only_out_tttttttblbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttblbt = _cast11 Unmanaged._embedding_bag_forward_only_out_tttttttblbt
+
+_embedding_bag_forward_only_out_tttttttblb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttblb = _cast10 Unmanaged._embedding_bag_forward_only_out_tttttttblb
+
+_embedding_bag_forward_only_out_tttttttbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttbl = _cast9 Unmanaged._embedding_bag_forward_only_out_tttttttbl
+
+_embedding_bag_forward_only_out_tttttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttb = _cast8 Unmanaged._embedding_bag_forward_only_out_tttttttb
+
+_embedding_bag_forward_only_out_ttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_ttttttt = _cast7 Unmanaged._embedding_bag_forward_only_out_ttttttt
+
+_embedding_bag_out_tttttttblbtbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttblbtbl = _cast13 Unmanaged._embedding_bag_out_tttttttblbtbl
+
+_embedding_bag_out_tttttttblbtb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttblbtb = _cast12 Unmanaged._embedding_bag_out_tttttttblbtb
+
+_embedding_bag_out_tttttttblbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttblbt = _cast11 Unmanaged._embedding_bag_out_tttttttblbt
+
+_embedding_bag_out_tttttttblb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttblb = _cast10 Unmanaged._embedding_bag_out_tttttttblb
+
+_embedding_bag_out_tttttttbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttbl = _cast9 Unmanaged._embedding_bag_out_tttttttbl
+
+_embedding_bag_out_tttttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttb = _cast8 Unmanaged._embedding_bag_out_tttttttb
+
+_embedding_bag_out_ttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_ttttttt = _cast7 Unmanaged._embedding_bag_out_ttttttt
+
+_embedding_bag_dense_backward_out_ttttttlbltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_dense_backward_out_ttttttlbltl = _cast11 Unmanaged._embedding_bag_dense_backward_out_ttttttlbltl
+
+_embedding_bag_dense_backward_out_ttttttlblt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_dense_backward_out_ttttttlblt = _cast10 Unmanaged._embedding_bag_dense_backward_out_ttttttlblt
+
+_embedding_bag_per_sample_weights_backward_out_ttttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_per_sample_weights_backward_out_ttttttll = _cast8 Unmanaged._embedding_bag_per_sample_weights_backward_out_ttttttll
+
+_embedding_bag_per_sample_weights_backward_out_ttttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_per_sample_weights_backward_out_ttttttl = _cast7 Unmanaged._embedding_bag_per_sample_weights_backward_out_ttttttl
+
+empty_out_tlNM
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_out_tlNM = _cast4 Unmanaged.empty_out_tlNM
+
+empty_out_tlN
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+empty_out_tlN = _cast3 Unmanaged.empty_out_tlN
+
+new_empty_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+new_empty_out_ttl = _cast3 Unmanaged.new_empty_out_ttl
+
+new_empty_strided_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+new_empty_strided_out_ttll = _cast4 Unmanaged.new_empty_strided_out_ttll
+
+new_full_out_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+new_full_out_ttls = _cast4 Unmanaged.new_full_out_ttls
+
+new_zeros_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+new_zeros_out_ttl = _cast3 Unmanaged.new_zeros_out_ttl
+
+new_ones_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+new_ones_out_ttl = _cast3 Unmanaged.new_ones_out_ttl
+
+_empty_affine_quantized_out_tldlM
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> Int64
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_out_tldlM = _cast5 Unmanaged._empty_affine_quantized_out_tldlM
+
+_empty_affine_quantized_out_tldl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_out_tldl = _cast4 Unmanaged._empty_affine_quantized_out_tldl
+
+_empty_affine_quantized_out_tld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_out_tld = _cast3 Unmanaged._empty_affine_quantized_out_tld
+
+_empty_affine_quantized_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_out_tl = _cast2 Unmanaged._empty_affine_quantized_out_tl
+
+_empty_per_channel_affine_quantized_out_tlttlM
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_empty_per_channel_affine_quantized_out_tlttlM = _cast6 Unmanaged._empty_per_channel_affine_quantized_out_tlttlM
+
+_empty_per_channel_affine_quantized_out_tlttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_empty_per_channel_affine_quantized_out_tlttl = _cast5 Unmanaged._empty_per_channel_affine_quantized_out_tlttl
+
+resize_out_ttlM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+resize_out_ttlM = _cast4 Unmanaged.resize_out_ttlM
+
+resize_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+resize_out_ttl = _cast3 Unmanaged.resize_out_ttl
+
+resize_tlM
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+resize_tlM = _cast3 Unmanaged.resize_tlM
+
+resize_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+resize_tl = _cast2 Unmanaged.resize_tl
+
+_resize_output_out_ttlD
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> DeviceType
+  -> IO (ForeignPtr Tensor)
+_resize_output_out_ttlD = _cast4 Unmanaged._resize_output_out_ttlD
+
+_resize_output_tlD
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> DeviceType
+  -> IO (ForeignPtr Tensor)
+_resize_output_tlD = _cast3 Unmanaged._resize_output_tlD
+
+empty_quantized_out_tltM
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_quantized_out_tltM = _cast4 Unmanaged.empty_quantized_out_tltM
+
+empty_quantized_out_tlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+empty_quantized_out_tlt = _cast3 Unmanaged.empty_quantized_out_tlt
+
+empty_like_out_ttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_like_out_ttM = _cast3 Unmanaged.empty_like_out_ttM
+
+empty_like_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+empty_like_out_tt = _cast2 Unmanaged.empty_like_out_tt
+
+empty_strided_out_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+empty_strided_out_tll = _cast3 Unmanaged.empty_strided_out_tll
+
+fill_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+fill_out_tts = _cast3 Unmanaged.fill_out_tts
+
+fill_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fill_out_ttt = _cast3 Unmanaged.fill_out_ttt
+
+full_out_tlsN
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+full_out_tlsN = _cast4 Unmanaged.full_out_tlsN
+
+full_like_out_ttsM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+full_like_out_ttsM = _cast4 Unmanaged.full_like_out_ttsM
+
+full_like_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+full_like_out_tts = _cast3 Unmanaged.full_like_out_tts
+
+from_file_out_tsbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+from_file_out_tsbl = _cast4 Unmanaged.from_file_out_tsbl
+
+from_file_out_tsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+from_file_out_tsb = _cast3 Unmanaged.from_file_out_tsb
+
+from_file_out_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+from_file_out_ts = _cast2 Unmanaged.from_file_out_ts
+
+grid_sampler_2d_out_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+grid_sampler_2d_out_tttllb = _cast6 Unmanaged.grid_sampler_2d_out_tttllb
+
+grid_sampler_2d_backward_out_tttttllba
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+grid_sampler_2d_backward_out_tttttllba = _cast9 Unmanaged.grid_sampler_2d_backward_out_tttttllba
+
+_grid_sampler_2d_cpu_fallback_out_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_grid_sampler_2d_cpu_fallback_out_tttllb = _cast6 Unmanaged._grid_sampler_2d_cpu_fallback_out_tttllb
+
+grid_sampler_3d_out_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+grid_sampler_3d_out_tttllb = _cast6 Unmanaged.grid_sampler_3d_out_tttllb
+
+grid_sampler_3d_backward_out_tttttllba
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+grid_sampler_3d_backward_out_tttttllba = _cast9 Unmanaged.grid_sampler_3d_backward_out_tttttllba
+
+hann_window_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+hann_window_out_tl = _cast2 Unmanaged.hann_window_out_tl
+
+hann_window_out_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+hann_window_out_tlb = _cast3 Unmanaged.hann_window_out_tlb
+
+hamming_window_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+hamming_window_out_tl = _cast2 Unmanaged.hamming_window_out_tl
+
+hamming_window_out_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+hamming_window_out_tlb = _cast3 Unmanaged.hamming_window_out_tlb
+
+hamming_window_out_tlbd
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+hamming_window_out_tlbd = _cast4 Unmanaged.hamming_window_out_tlbd
+
+hamming_window_out_tlbdd
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+hamming_window_out_tlbdd = _cast5 Unmanaged.hamming_window_out_tlbdd
+
+kaiser_window_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+kaiser_window_out_tl = _cast2 Unmanaged.kaiser_window_out_tl
+
+kaiser_window_out_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+kaiser_window_out_tlb = _cast3 Unmanaged.kaiser_window_out_tlb
+
+kaiser_window_out_tlbd
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+kaiser_window_out_tlbd = _cast4 Unmanaged.kaiser_window_out_tlbd
+
+native_group_norm_out_ttttttlllld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_group_norm_out_ttttttlllld = _cast11 Unmanaged.native_group_norm_out_ttttttlllld
+
+native_group_norm_backward_out_ttttttttlllla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_group_norm_backward_out_ttttttttlllla = _cast13 Unmanaged.native_group_norm_backward_out_ttttttttlllla
+
+index_put_out_ttltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+index_put_out_ttltb = _cast5 Unmanaged.index_put_out_ttltb
+
+index_put_out_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_put_out_ttlt = _cast4 Unmanaged.index_put_out_ttlt
+
+_index_put_impl_out_ttltbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_index_put_impl_out_ttltbb = _cast6 Unmanaged._index_put_impl_out_ttltbb
+
+_index_put_impl_out_ttltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_index_put_impl_out_ttltb = _cast5 Unmanaged._index_put_impl_out_ttltb
+
+_index_put_impl_out_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_index_put_impl_out_ttlt = _cast4 Unmanaged._index_put_impl_out_ttlt
+
+_index_put_impl_tltbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_index_put_impl_tltbb = _cast5 Unmanaged._index_put_impl_tltbb
+
+_index_put_impl_tltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_index_put_impl_tltb = _cast4 Unmanaged._index_put_impl_tltb
+
+_index_put_impl_tlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_index_put_impl_tlt = _cast3 Unmanaged._index_put_impl_tlt
+
+isnan_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isnan_out_tt = _cast2 Unmanaged.isnan_out_tt
+
+native_layer_norm_out_ttttlttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_layer_norm_out_ttttlttd = _cast8 Unmanaged.native_layer_norm_out_ttttlttd
+
+native_layer_norm_backward_out_tttttltttta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_layer_norm_backward_out_tttttltttta = _cast11 Unmanaged.native_layer_norm_backward_out_tttttltttta
+
+linear_backward_out_tttttta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linear_backward_out_tttttta = _cast7 Unmanaged.linear_backward_out_tttttta
+
+mkldnn_linear_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_linear_out_tttt = _cast4 Unmanaged.mkldnn_linear_out_tttt
+
+mkldnn_linear_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_linear_out_ttt = _cast3 Unmanaged.mkldnn_linear_out_ttt
+
+mkldnn_linear_backward_input_out_tltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_linear_backward_input_out_tltt = _cast4 Unmanaged.mkldnn_linear_backward_input_out_tltt
+
+mkldnn_linear_backward_weights_out_tttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mkldnn_linear_backward_weights_out_tttttb = _cast6 Unmanaged.mkldnn_linear_backward_weights_out_tttttb
+
+mkldnn_linear_backward_out_tttttta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+mkldnn_linear_backward_out_tttttta = _cast7 Unmanaged.mkldnn_linear_backward_out_tttttta
+
+matmul_backward_out_ttttta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+matmul_backward_out_ttttta = _cast6 Unmanaged.matmul_backward_out_ttttta
+
+_aminmax_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_aminmax_out_ttt = _cast3 Unmanaged._aminmax_out_ttt
+
+_aminmax_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_aminmax_out_tttlb = _cast5 Unmanaged._aminmax_out_tttlb
+
+_aminmax_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_aminmax_out_tttl = _cast4 Unmanaged._aminmax_out_tttl
+
+max_pool2d_backward_out_tttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_out_tttllllb = _cast8 Unmanaged.max_pool2d_backward_out_tttllllb
+
+max_pool2d_backward_out_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_out_tttllll = _cast7 Unmanaged.max_pool2d_backward_out_tttllll
+
+max_pool2d_backward_out_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_out_tttlll = _cast6 Unmanaged.max_pool2d_backward_out_tttlll
+
+max_pool2d_backward_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_out_tttll = _cast5 Unmanaged.max_pool2d_backward_out_tttll
+
+max_pool2d_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_out_tttl = _cast4 Unmanaged.max_pool2d_backward_out_tttl
+
+mkldnn_max_pool2d_out_ttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_out_ttllllb = _cast7 Unmanaged.mkldnn_max_pool2d_out_ttllllb
+
+mkldnn_max_pool2d_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_out_ttllll = _cast6 Unmanaged.mkldnn_max_pool2d_out_ttllll
+
+mkldnn_max_pool2d_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_out_ttlll = _cast5 Unmanaged.mkldnn_max_pool2d_out_ttlll
+
+mkldnn_max_pool2d_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_out_ttll = _cast4 Unmanaged.mkldnn_max_pool2d_out_ttll
+
+mkldnn_max_pool2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_out_ttl = _cast3 Unmanaged.mkldnn_max_pool2d_out_ttl
+
+mkldnn_max_pool2d_backward_out_ttttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_out_ttttllllb = _cast9 Unmanaged.mkldnn_max_pool2d_backward_out_ttttllllb
+
+mkldnn_max_pool2d_backward_out_ttttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_out_ttttllll = _cast8 Unmanaged.mkldnn_max_pool2d_backward_out_ttttllll
+
+mkldnn_max_pool2d_backward_out_ttttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_out_ttttlll = _cast7 Unmanaged.mkldnn_max_pool2d_backward_out_ttttlll
+
+mkldnn_max_pool2d_backward_out_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_out_ttttll = _cast6 Unmanaged.mkldnn_max_pool2d_backward_out_ttttll
+
+mkldnn_max_pool2d_backward_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_out_ttttl = _cast5 Unmanaged.mkldnn_max_pool2d_backward_out_ttttl
+
+mkldnn_max_pool3d_out_ttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_out_ttllllb = _cast7 Unmanaged.mkldnn_max_pool3d_out_ttllllb
+
+mkldnn_max_pool3d_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_out_ttllll = _cast6 Unmanaged.mkldnn_max_pool3d_out_ttllll
+
+mkldnn_max_pool3d_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_out_ttlll = _cast5 Unmanaged.mkldnn_max_pool3d_out_ttlll
+
+mkldnn_max_pool3d_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_out_ttll = _cast4 Unmanaged.mkldnn_max_pool3d_out_ttll
+
+mkldnn_max_pool3d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_out_ttl = _cast3 Unmanaged.mkldnn_max_pool3d_out_ttl
+
+mkldnn_max_pool3d_backward_out_ttttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_out_ttttllllb = _cast9 Unmanaged.mkldnn_max_pool3d_backward_out_ttttllllb
+
+mkldnn_max_pool3d_backward_out_ttttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_out_ttttllll = _cast8 Unmanaged.mkldnn_max_pool3d_backward_out_ttttllll
+
+mkldnn_max_pool3d_backward_out_ttttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_out_ttttlll = _cast7 Unmanaged.mkldnn_max_pool3d_backward_out_ttttlll
+
+mkldnn_max_pool3d_backward_out_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_out_ttttll = _cast6 Unmanaged.mkldnn_max_pool3d_backward_out_ttttll
+
+mkldnn_max_pool3d_backward_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_out_ttttl = _cast5 Unmanaged.mkldnn_max_pool3d_backward_out_ttttl
+
+quantized_max_pool1d_out_ttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_out_ttllllb = _cast7 Unmanaged.quantized_max_pool1d_out_ttllllb
+
+quantized_max_pool1d_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_out_ttllll = _cast6 Unmanaged.quantized_max_pool1d_out_ttllll
+
+quantized_max_pool1d_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_out_ttlll = _cast5 Unmanaged.quantized_max_pool1d_out_ttlll
+
+quantized_max_pool1d_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_out_ttll = _cast4 Unmanaged.quantized_max_pool1d_out_ttll
+
+quantized_max_pool1d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_out_ttl = _cast3 Unmanaged.quantized_max_pool1d_out_ttl
+
+quantized_max_pool2d_out_ttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_out_ttllllb = _cast7 Unmanaged.quantized_max_pool2d_out_ttllllb
+
+quantized_max_pool2d_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_out_ttllll = _cast6 Unmanaged.quantized_max_pool2d_out_ttllll
+
+quantized_max_pool2d_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_out_ttlll = _cast5 Unmanaged.quantized_max_pool2d_out_ttlll
+
+quantized_max_pool2d_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_out_ttll = _cast4 Unmanaged.quantized_max_pool2d_out_ttll
+
+quantized_max_pool2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_out_ttl = _cast3 Unmanaged.quantized_max_pool2d_out_ttl
+
+median_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+median_out_tt = _cast2 Unmanaged.median_out_tt
+
+nanmedian_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nanmedian_out_tt = _cast2 Unmanaged.nanmedian_out_tt
+
+_mps_convolution_out_ttttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_mps_convolution_out_ttttllll = _cast8 Unmanaged._mps_convolution_out_ttttllll
+
+mps_convolution_backward_out_ttttttlllla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+mps_convolution_backward_out_ttttttlllla = _cast11 Unmanaged.mps_convolution_backward_out_ttttttlllla
+
+mkldnn_convolution_out_ttttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mkldnn_convolution_out_ttttllll = _cast8 Unmanaged.mkldnn_convolution_out_ttttllll
+
+mkldnn_rnn_layer_out_tttttttttttbllllbbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+mkldnn_rnn_layer_out_tttttttttttbllllbbbb = _cast20 Unmanaged.mkldnn_rnn_layer_out_tttttttttttbllllbbbb
+
+mkldnn_rnn_layer_backward_out_ttttttttttttttttttttblllbbblbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+mkldnn_rnn_layer_backward_out_ttttttttttttttttttttblllbbblbt = _cast30 Unmanaged.mkldnn_rnn_layer_backward_out_ttttttttttttttttttttblllbbblbt
+
+miopen_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)))
+miopen_batch_norm_out_ttttttttbdd = _cast11 Unmanaged.miopen_batch_norm_out_ttttttttbdd
+
+miopen_batch_norm_backward_out_ttttttttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+miopen_batch_norm_backward_out_ttttttttttd = _cast11 Unmanaged.miopen_batch_norm_backward_out_ttttttttttd
+
diff --git a/src/Torch/Internal/Managed/Native/Native14.hs b/src/Torch/Internal/Managed/Native/Native14.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native14.hs
@@ -0,0 +1,2414 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native14 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native14 as Unmanaged
+
+
+miopen_convolution_out_ttttllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+miopen_convolution_out_ttttllllbb = _cast10 Unmanaged.miopen_convolution_out_ttttllllbb
+
+miopen_convolution_transpose_out_ttttlllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+miopen_convolution_transpose_out_ttttlllllbb = _cast11 Unmanaged.miopen_convolution_transpose_out_ttttlllllbb
+
+miopen_depthwise_convolution_out_ttttllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+miopen_depthwise_convolution_out_ttttllllbb = _cast10 Unmanaged.miopen_depthwise_convolution_out_ttttllllbb
+
+miopen_rnn_out_ttttttllttlllbdbblt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+miopen_rnn_out_ttttttllttlllbdbblt = _cast19 Unmanaged.miopen_rnn_out_ttttttllttlllbdbblt
+
+miopen_rnn_backward_out_tttltlltttttttlllbdbbltta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,4))
+  -> IO (())
+miopen_rnn_backward_out_tttltlltttttttlllbdbbltta = _cast25 Unmanaged.miopen_rnn_backward_out_tttltlltttttttlllbdbbltta
+
+_sparse_sparse_matmul_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_sparse_matmul_out_ttt = _cast3 Unmanaged._sparse_sparse_matmul_out_ttt
+
+mul_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+mul_out_tts = _cast3 Unmanaged.mul_out_tts
+
+_native_batch_norm_legit_functional_tttttbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_native_batch_norm_legit_functional_tttttbdd = _cast8 Unmanaged._native_batch_norm_legit_functional_tttttbdd
+
+batch_norm_stats_out_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+batch_norm_stats_out_tttd = _cast4 Unmanaged.batch_norm_stats_out_tttd
+
+batch_norm_gather_stats_out_tttttttddl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+batch_norm_gather_stats_out_tttttttddl = _cast10 Unmanaged.batch_norm_gather_stats_out_tttttttddl
+
+batch_norm_gather_stats_with_counts_out_tttttttddt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+batch_norm_gather_stats_with_counts_out_tttttttddt = _cast10 Unmanaged.batch_norm_gather_stats_with_counts_out_tttttttddt
+
+native_batch_norm_backward_out_ttttttttttbda
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_batch_norm_backward_out_ttttttttttbda = _cast13 Unmanaged.native_batch_norm_backward_out_ttttttttttbda
+
+batch_norm_backward_reduce_out_tttttttttbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+batch_norm_backward_reduce_out_tttttttttbbb = _cast12 Unmanaged.batch_norm_backward_reduce_out_tttttttttbbb
+
+batch_norm_backward_elemt_out_ttttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+batch_norm_backward_elemt_out_ttttttttt = _cast9 Unmanaged.batch_norm_backward_elemt_out_ttttttttt
+
+batch_norm_update_stats_out_tttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+batch_norm_update_stats_out_tttttd = _cast6 Unmanaged.batch_norm_update_stats_out_tttttd
+
+_nnpack_spatial_convolution_out_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_nnpack_spatial_convolution_out_ttttll = _cast6 Unmanaged._nnpack_spatial_convolution_out_ttttll
+
+_nnpack_spatial_convolution_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_nnpack_spatial_convolution_out_ttttl = _cast5 Unmanaged._nnpack_spatial_convolution_out_ttttl
+
+ones_out_tlN
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+ones_out_tlN = _cast3 Unmanaged.ones_out_tlN
+
+ones_like_out_ttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+ones_like_out_ttM = _cast3 Unmanaged.ones_like_out_ttM
+
+ones_like_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ones_like_out_tt = _cast2 Unmanaged.ones_like_out_tt
+
+_euclidean_dist_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_euclidean_dist_out_ttt = _cast3 Unmanaged._euclidean_dist_out_ttt
+
+_cdist_forward_out_tttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_cdist_forward_out_tttdl = _cast5 Unmanaged._cdist_forward_out_tttdl
+
+_cdist_backward_out_ttttdt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cdist_backward_out_ttttdt = _cast6 Unmanaged._cdist_backward_out_ttttdt
+
+_pdist_forward_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_pdist_forward_out_ttd = _cast3 Unmanaged._pdist_forward_out_ttd
+
+_pdist_forward_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_pdist_forward_out_tt = _cast2 Unmanaged._pdist_forward_out_tt
+
+_pdist_backward_out_tttdt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_pdist_backward_out_tttdt = _cast5 Unmanaged._pdist_backward_out_tttdt
+
+pixel_shuffle_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+pixel_shuffle_out_ttl = _cast3 Unmanaged.pixel_shuffle_out_ttl
+
+pixel_unshuffle_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+pixel_unshuffle_out_ttl = _cast3 Unmanaged.pixel_unshuffle_out_ttl
+
+channel_shuffle_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+channel_shuffle_out_ttl = _cast3 Unmanaged.channel_shuffle_out_ttl
+
+_pin_memory_out_ttD
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> DeviceType
+  -> IO (ForeignPtr Tensor)
+_pin_memory_out_ttD = _cast3 Unmanaged._pin_memory_out_ttD
+
+_pin_memory_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_pin_memory_out_tt = _cast2 Unmanaged._pin_memory_out_tt
+
+scalar_tensor_out_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+scalar_tensor_out_ts = _cast2 Unmanaged.scalar_tensor_out_ts
+
+rand_out_tlN
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+rand_out_tlN = _cast3 Unmanaged.rand_out_tlN
+
+rand_out_tlGN
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+rand_out_tlGN = _cast4 Unmanaged.rand_out_tlGN
+
+rand_like_out_ttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+rand_like_out_ttM = _cast3 Unmanaged.rand_like_out_ttM
+
+rand_like_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rand_like_out_tt = _cast2 Unmanaged.rand_like_out_tt
+
+randint_like_out_ttlM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randint_like_out_ttlM = _cast4 Unmanaged.randint_like_out_ttlM
+
+randint_like_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+randint_like_out_ttl = _cast3 Unmanaged.randint_like_out_ttl
+
+randint_like_out_ttllM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randint_like_out_ttllM = _cast5 Unmanaged.randint_like_out_ttllM
+
+randint_like_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+randint_like_out_ttll = _cast4 Unmanaged.randint_like_out_ttll
+
+randn_out_tlN
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+randn_out_tlN = _cast3 Unmanaged.randn_out_tlN
+
+randn_out_tlGN
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+randn_out_tlGN = _cast4 Unmanaged.randn_out_tlGN
+
+randn_like_out_ttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randn_like_out_ttM = _cast3 Unmanaged.randn_like_out_ttM
+
+randn_like_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+randn_like_out_tt = _cast2 Unmanaged.randn_like_out_tt
+
+repeat_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+repeat_out_ttl = _cast3 Unmanaged.repeat_out_ttl
+
+repeat_interleave_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_out_ttl = _cast3 Unmanaged.repeat_interleave_out_ttl
+
+repeat_interleave_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_out_tt = _cast2 Unmanaged.repeat_interleave_out_tt
+
+_mkldnn_reshape_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_mkldnn_reshape_out_ttl = _cast3 Unmanaged._mkldnn_reshape_out_ttl
+
+relu_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+relu_out_tt = _cast2 Unmanaged.relu_out_tt
+
+select_backward_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+select_backward_out_ttlll = _cast5 Unmanaged.select_backward_out_ttlll
+
+celu_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+celu_out_tts = _cast3 Unmanaged.celu_out_tts
+
+celu_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+celu_out_tt = _cast2 Unmanaged.celu_out_tt
+
+slice_backward_out_ttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_backward_out_ttlllll = _cast7 Unmanaged.slice_backward_out_ttlllll
+
+slice_scatter_out_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_scatter_out_tttllll = _cast7 Unmanaged.slice_scatter_out_tttllll
+
+slice_scatter_out_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_scatter_out_tttlll = _cast6 Unmanaged.slice_scatter_out_tttlll
+
+slice_scatter_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_scatter_out_tttll = _cast5 Unmanaged.slice_scatter_out_tttll
+
+slice_scatter_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_scatter_out_tttl = _cast4 Unmanaged.slice_scatter_out_tttl
+
+slice_scatter_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slice_scatter_out_ttt = _cast3 Unmanaged.slice_scatter_out_ttt
+
+select_scatter_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+select_scatter_out_tttll = _cast5 Unmanaged.select_scatter_out_tttll
+
+diagonal_scatter_out_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_scatter_out_tttlll = _cast6 Unmanaged.diagonal_scatter_out_tttlll
+
+diagonal_scatter_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_scatter_out_tttll = _cast5 Unmanaged.diagonal_scatter_out_tttll
+
+diagonal_scatter_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_scatter_out_tttl = _cast4 Unmanaged.diagonal_scatter_out_tttl
+
+diagonal_scatter_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diagonal_scatter_out_ttt = _cast3 Unmanaged.diagonal_scatter_out_ttt
+
+as_strided_scatter_out_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+as_strided_scatter_out_tttlll = _cast6 Unmanaged.as_strided_scatter_out_tttlll
+
+as_strided_scatter_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+as_strided_scatter_out_tttll = _cast5 Unmanaged.as_strided_scatter_out_tttll
+
+unsafe_split_out_ltll
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (())
+unsafe_split_out_ltll = _cast4 Unmanaged.unsafe_split_out_ltll
+
+unsafe_split_out_ltl
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (())
+unsafe_split_out_ltl = _cast3 Unmanaged.unsafe_split_out_ltl
+
+unsafe_split_with_sizes_out_ltll
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (())
+unsafe_split_with_sizes_out_ltll = _cast4 Unmanaged.unsafe_split_with_sizes_out_ltll
+
+unsafe_split_with_sizes_out_ltl
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+unsafe_split_with_sizes_out_ltl = _cast3 Unmanaged.unsafe_split_with_sizes_out_ltl
+
+sum_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+sum_out_tts = _cast3 Unmanaged.sum_out_tts
+
+sum_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sum_out_tt = _cast2 Unmanaged.sum_out_tt
+
+std_mean_out_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_out_tttllb = _cast6 Unmanaged.std_mean_out_tttllb
+
+std_mean_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_out_tttll = _cast5 Unmanaged.std_mean_out_tttll
+
+std_mean_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_out_tttl = _cast4 Unmanaged.std_mean_out_tttl
+
+std_mean_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_out_ttt = _cast3 Unmanaged.std_mean_out_ttt
+
+prod_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+prod_out_tts = _cast3 Unmanaged.prod_out_tts
+
+prod_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+prod_out_tt = _cast2 Unmanaged.prod_out_tt
+
+_mkldnn_transpose_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_mkldnn_transpose_out_ttll = _cast4 Unmanaged._mkldnn_transpose_out_ttll
+
+flip_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+flip_out_ttl = _cast3 Unmanaged.flip_out_ttl
+
+roll_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+roll_out_ttll = _cast4 Unmanaged.roll_out_ttll
+
+roll_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+roll_out_ttl = _cast3 Unmanaged.roll_out_ttl
+
+rot90_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+rot90_out_ttll = _cast4 Unmanaged.rot90_out_ttll
+
+rot90_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+rot90_out_ttl = _cast3 Unmanaged.rot90_out_ttl
+
+rot90_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rot90_out_tt = _cast2 Unmanaged.rot90_out_tt
+
+_transform_bias_rescale_qkv_out_tttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_transform_bias_rescale_qkv_out_tttttl = _cast6 Unmanaged._transform_bias_rescale_qkv_out_tttttl
+
+_nested_tensor_from_mask_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_mask_out_tttb = _cast4 Unmanaged._nested_tensor_from_mask_out_tttb
+
+_nested_tensor_from_mask_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_mask_out_ttt = _cast3 Unmanaged._nested_tensor_from_mask_out_ttt
+
+_nested_from_padded_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_nested_from_padded_out_tttb = _cast4 Unmanaged._nested_from_padded_out_tttb
+
+_nested_from_padded_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_from_padded_out_ttt = _cast3 Unmanaged._nested_from_padded_out_ttt
+
+_nested_tensor_size_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_size_out_tt = _cast2 Unmanaged._nested_tensor_size_out_tt
+
+_nested_tensor_strides_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_strides_out_tt = _cast2 Unmanaged._nested_tensor_strides_out_tt
+
+_nested_from_padded_and_nested_example_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_from_padded_and_nested_example_out_ttt = _cast3 Unmanaged._nested_from_padded_and_nested_example_out_ttt
+
+_trilinear_out_ttttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_trilinear_out_ttttlllll = _cast9 Unmanaged._trilinear_out_ttttlllll
+
+_trilinear_out_ttttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_trilinear_out_ttttllll = _cast8 Unmanaged._trilinear_out_ttttllll
+
+_unique_out_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_unique_out_tttbb = _cast5 Unmanaged._unique_out_tttbb
+
+_unique_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_unique_out_tttb = _cast4 Unmanaged._unique_out_tttb
+
+_unique_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_unique_out_ttt = _cast3 Unmanaged._unique_out_ttt
+
+unique_dim_out_ttttlbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_out_ttttlbbb = _cast8 Unmanaged.unique_dim_out_ttttlbbb
+
+unique_dim_out_ttttlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_out_ttttlbb = _cast7 Unmanaged.unique_dim_out_ttttlbb
+
+unique_dim_out_ttttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_out_ttttlb = _cast6 Unmanaged.unique_dim_out_ttttlb
+
+unique_dim_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_out_ttttl = _cast5 Unmanaged.unique_dim_out_ttttl
+
+unique_consecutive_out_ttttbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_out_ttttbbl = _cast7 Unmanaged.unique_consecutive_out_ttttbbl
+
+unique_consecutive_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_out_ttttbb = _cast6 Unmanaged.unique_consecutive_out_ttttbb
+
+unique_consecutive_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_out_ttttb = _cast5 Unmanaged.unique_consecutive_out_ttttb
+
+unique_consecutive_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_out_tttt = _cast4 Unmanaged.unique_consecutive_out_tttt
+
+unique_dim_consecutive_out_ttttlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_out_ttttlbb = _cast7 Unmanaged.unique_dim_consecutive_out_ttttlbb
+
+unique_dim_consecutive_out_ttttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_out_ttttlb = _cast6 Unmanaged.unique_dim_consecutive_out_ttttlb
+
+unique_dim_consecutive_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_out_ttttl = _cast5 Unmanaged.unique_dim_consecutive_out_ttttl
+
+_unique2_out_ttttbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_out_ttttbbb = _cast7 Unmanaged._unique2_out_ttttbbb
+
+_unique2_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_out_ttttbb = _cast6 Unmanaged._unique2_out_ttttbb
+
+_unique2_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_out_ttttb = _cast5 Unmanaged._unique2_out_ttttb
+
+_unique2_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_out_tttt = _cast4 Unmanaged._unique2_out_tttt
+
+_unsafe_view_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_unsafe_view_out_ttl = _cast3 Unmanaged._unsafe_view_out_ttl
+
+var_mean_out_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_out_tttllb = _cast6 Unmanaged.var_mean_out_tttllb
+
+var_mean_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_out_tttll = _cast5 Unmanaged.var_mean_out_tttll
+
+var_mean_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_out_tttl = _cast4 Unmanaged.var_mean_out_tttl
+
+var_mean_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_out_ttt = _cast3 Unmanaged.var_mean_out_ttt
+
+_weight_norm_interface_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_out_ttttl = _cast5 Unmanaged._weight_norm_interface_out_ttttl
+
+_weight_norm_interface_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_out_tttt = _cast4 Unmanaged._weight_norm_interface_out_tttt
+
+_weight_norm_interface_backward_out_ttttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_backward_out_ttttttl = _cast7 Unmanaged._weight_norm_interface_backward_out_ttttttl
+
+zeros_out_tlN
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+zeros_out_tlN = _cast3 Unmanaged.zeros_out_tlN
+
+_efficientzerotensor_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_efficientzerotensor_out_tl = _cast2 Unmanaged._efficientzerotensor_out_tl
+
+zeros_like_out_ttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+zeros_like_out_ttM = _cast3 Unmanaged.zeros_like_out_ttM
+
+zeros_like_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+zeros_like_out_tt = _cast2 Unmanaged.zeros_like_out_tt
+
+_standard_gamma_grad_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_standard_gamma_grad_out_ttt = _cast3 Unmanaged._standard_gamma_grad_out_ttt
+
+_standard_gamma_out_ttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+_standard_gamma_out_ttG = _cast3 Unmanaged._standard_gamma_out_ttG
+
+_standard_gamma_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_standard_gamma_out_tt = _cast2 Unmanaged._standard_gamma_out_tt
+
+_dirichlet_grad_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_dirichlet_grad_out_tttt = _cast4 Unmanaged._dirichlet_grad_out_tttt
+
+_sample_dirichlet_out_ttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+_sample_dirichlet_out_ttG = _cast3 Unmanaged._sample_dirichlet_out_ttG
+
+_sample_dirichlet_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sample_dirichlet_out_tt = _cast2 Unmanaged._sample_dirichlet_out_tt
+
+poisson_out_ttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+poisson_out_ttG = _cast3 Unmanaged.poisson_out_ttG
+
+poisson_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+poisson_out_tt = _cast2 Unmanaged.poisson_out_tt
+
+binomial_out_tttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+binomial_out_tttG = _cast4 Unmanaged.binomial_out_tttG
+
+binomial_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binomial_out_ttt = _cast3 Unmanaged.binomial_out_ttt
+
+native_norm_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+native_norm_out_tts = _cast3 Unmanaged.native_norm_out_tts
+
+native_norm_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+native_norm_out_tt = _cast2 Unmanaged.native_norm_out_tt
+
+native_norm_out_ttslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+native_norm_out_ttslbs = _cast6 Unmanaged.native_norm_out_ttslbs
+
+_sparse_sum_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_sum_out_ttl = _cast3 Unmanaged._sparse_sum_out_ttl
+
+_sparse_sum_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_sum_backward_out_tttl = _cast4 Unmanaged._sparse_sum_backward_out_tttl
+
+_sparse_csr_sum_out_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_sum_out_ttlbs = _cast5 Unmanaged._sparse_csr_sum_out_ttlbs
+
+_sparse_csr_sum_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_sum_out_ttlb = _cast4 Unmanaged._sparse_csr_sum_out_ttlb
+
+_sparse_csr_sum_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_sum_out_ttl = _cast3 Unmanaged._sparse_csr_sum_out_ttl
+
+_sparse_csr_prod_out_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_prod_out_ttlbs = _cast5 Unmanaged._sparse_csr_prod_out_ttlbs
+
+_sparse_csr_prod_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_prod_out_ttlb = _cast4 Unmanaged._sparse_csr_prod_out_ttlb
+
+_sparse_csr_prod_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_prod_out_ttl = _cast3 Unmanaged._sparse_csr_prod_out_ttl
+
+_sparse_softmax_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_sparse_softmax_out_ttlb = _cast4 Unmanaged._sparse_softmax_out_ttlb
+
+_sparse_softmax_backward_data_out_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_softmax_backward_data_out_tttlt = _cast5 Unmanaged._sparse_softmax_backward_data_out_tttlt
+
+_sparse_log_softmax_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_sparse_log_softmax_out_ttlb = _cast4 Unmanaged._sparse_log_softmax_out_ttlb
+
+_sparse_log_softmax_backward_data_out_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_log_softmax_backward_data_out_tttlt = _cast5 Unmanaged._sparse_log_softmax_backward_data_out_tttlt
+
+_spdiags_out_tttlL
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Layout
+  -> IO (ForeignPtr Tensor)
+_spdiags_out_tttlL = _cast5 Unmanaged._spdiags_out_tttlL
+
+_spdiags_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_spdiags_out_tttl = _cast4 Unmanaged._spdiags_out_tttl
+
+norm_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+norm_out_ttss = _cast4 Unmanaged.norm_out_ttss
+
+norm_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+norm_out_tts = _cast3 Unmanaged.norm_out_tts
+
+norm_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+norm_out_tt = _cast2 Unmanaged.norm_out_tt
+
+clone_out_ttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+clone_out_ttM = _cast3 Unmanaged.clone_out_ttM
+
+clone_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clone_out_tt = _cast2 Unmanaged.clone_out_tt
+
+resize_as_out_tttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+resize_as_out_tttM = _cast4 Unmanaged.resize_as_out_tttM
+
+resize_as_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+resize_as_out_ttt = _cast3 Unmanaged.resize_as_out_ttt
+
+resize_as_ttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+resize_as_ttM = _cast3 Unmanaged.resize_as_ttM
+
+resize_as_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+resize_as_tt = _cast2 Unmanaged.resize_as_tt
+
+resize_as_sparse_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+resize_as_sparse_out_ttt = _cast3 Unmanaged.resize_as_sparse_out_ttt
+
+resize_as_sparse_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+resize_as_sparse_tt = _cast2 Unmanaged.resize_as_sparse_tt
+
+zero_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+zero_out_tt = _cast2 Unmanaged.zero_out_tt
+
+zero_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+zero_t = _cast1 Unmanaged.zero_t
+
+sub_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sub_out_ttss = _cast4 Unmanaged.sub_out_ttss
+
+sub_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sub_out_tts = _cast3 Unmanaged.sub_out_tts
+
+rsub_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rsub_out_ttts = _cast4 Unmanaged.rsub_out_ttts
+
+rsub_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rsub_out_ttt = _cast3 Unmanaged.rsub_out_ttt
+
+rsub_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rsub_out_ttss = _cast4 Unmanaged.rsub_out_ttss
+
+rsub_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rsub_out_tts = _cast3 Unmanaged.rsub_out_tts
+
+_sparse_addmm_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_sparse_addmm_out_ttttss = _cast6 Unmanaged._sparse_addmm_out_ttttss
+
+_sparse_addmm_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_sparse_addmm_out_tttts = _cast5 Unmanaged._sparse_addmm_out_tttts
+
+_sparse_addmm_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_addmm_out_tttt = _cast4 Unmanaged._sparse_addmm_out_tttt
+
+sparse_coo_tensor_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_out_tl = _cast2 Unmanaged.sparse_coo_tensor_out_tl
+
+_sparse_coo_tensor_with_dims_out_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_with_dims_out_tlll = _cast4 Unmanaged._sparse_coo_tensor_with_dims_out_tlll
+
+_sparse_coo_tensor_with_dims_and_tensors_out_tllltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_with_dims_and_tensors_out_tllltt = _cast6 Unmanaged._sparse_coo_tensor_with_dims_and_tensors_out_tllltt
+
+sparse_resize_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+sparse_resize_out_ttlll = _cast5 Unmanaged.sparse_resize_out_ttlll
+
+sparse_resize_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+sparse_resize_tlll = _cast4 Unmanaged.sparse_resize_tlll
+
+sparse_resize_and_clear_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+sparse_resize_and_clear_out_ttlll = _cast5 Unmanaged.sparse_resize_and_clear_out_ttlll
+
+sparse_resize_and_clear_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+sparse_resize_and_clear_tlll = _cast4 Unmanaged.sparse_resize_and_clear_tlll
+
+sparse_mask_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sparse_mask_out_ttt = _cast3 Unmanaged.sparse_mask_out_ttt
+
+_to_dense_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_to_dense_out_tts = _cast3 Unmanaged._to_dense_out_tts
+
+_to_dense_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_to_dense_out_tt = _cast2 Unmanaged._to_dense_out_tt
+
+_coalesce_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_coalesce_out_tt = _cast2 Unmanaged._coalesce_out_tt
+
+_coalesced_out_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_coalesced_out_ttb = _cast3 Unmanaged._coalesced_out_ttb
+
+_coalesced_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_coalesced_tb = _cast2 Unmanaged._coalesced_tb
+
+copy_sparse_to_sparse_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+copy_sparse_to_sparse_out_tttb = _cast4 Unmanaged.copy_sparse_to_sparse_out_tttb
+
+copy_sparse_to_sparse_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+copy_sparse_to_sparse_out_ttt = _cast3 Unmanaged.copy_sparse_to_sparse_out_ttt
+
+copy_sparse_to_sparse_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+copy_sparse_to_sparse_ttb = _cast3 Unmanaged.copy_sparse_to_sparse_ttb
+
+copy_sparse_to_sparse_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+copy_sparse_to_sparse_tt = _cast2 Unmanaged.copy_sparse_to_sparse_tt
+
+to_mkldnn_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+to_mkldnn_out_tts = _cast3 Unmanaged.to_mkldnn_out_tts
+
+to_mkldnn_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+to_mkldnn_out_tt = _cast2 Unmanaged.to_mkldnn_out_tt
+
+mkldnn_reorder_conv2d_weight_out_ttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttlllll = _cast7 Unmanaged.mkldnn_reorder_conv2d_weight_out_ttlllll
+
+mkldnn_reorder_conv2d_weight_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttllll = _cast6 Unmanaged.mkldnn_reorder_conv2d_weight_out_ttllll
+
+mkldnn_reorder_conv2d_weight_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttlll = _cast5 Unmanaged.mkldnn_reorder_conv2d_weight_out_ttlll
+
+mkldnn_reorder_conv2d_weight_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttll = _cast4 Unmanaged.mkldnn_reorder_conv2d_weight_out_ttll
+
+mkldnn_reorder_conv2d_weight_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttl = _cast3 Unmanaged.mkldnn_reorder_conv2d_weight_out_ttl
+
+mkldnn_reorder_conv2d_weight_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_out_tt = _cast2 Unmanaged.mkldnn_reorder_conv2d_weight_out_tt
+
+mkldnn_reorder_conv3d_weight_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_out_ttllll = _cast6 Unmanaged.mkldnn_reorder_conv3d_weight_out_ttllll
+
+mkldnn_reorder_conv3d_weight_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_out_ttlll = _cast5 Unmanaged.mkldnn_reorder_conv3d_weight_out_ttlll
+
+mkldnn_reorder_conv3d_weight_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_out_ttll = _cast4 Unmanaged.mkldnn_reorder_conv3d_weight_out_ttll
+
+mkldnn_reorder_conv3d_weight_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_out_ttl = _cast3 Unmanaged.mkldnn_reorder_conv3d_weight_out_ttl
+
+mkldnn_reorder_conv3d_weight_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_out_tt = _cast2 Unmanaged.mkldnn_reorder_conv3d_weight_out_tt
+
+quantize_per_tensor_dynamic_out_ttsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantize_per_tensor_dynamic_out_ttsb = _cast4 Unmanaged.quantize_per_tensor_dynamic_out_ttsb
+
+quantize_per_tensor_out_ttdls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+quantize_per_tensor_out_ttdls = _cast5 Unmanaged.quantize_per_tensor_out_ttdls
+
+quantize_per_tensor_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+quantize_per_tensor_out_tttts = _cast5 Unmanaged.quantize_per_tensor_out_tttts
+
+quantize_per_tensor_out_lltts
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (())
+quantize_per_tensor_out_lltts = _cast5 Unmanaged.quantize_per_tensor_out_lltts
+
+quantize_per_channel_out_ttttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+quantize_per_channel_out_ttttls = _cast6 Unmanaged.quantize_per_channel_out_ttttls
+
+dequantize_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+dequantize_out_tt = _cast2 Unmanaged.dequantize_out_tt
+
+dequantize_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+dequantize_out_ll = _cast2 Unmanaged.dequantize_out_ll
+
+q_per_channel_scales_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+q_per_channel_scales_out_tt = _cast2 Unmanaged.q_per_channel_scales_out_tt
+
+q_per_channel_zero_points_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+q_per_channel_zero_points_out_tt = _cast2 Unmanaged.q_per_channel_zero_points_out_tt
+
+int_repr_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+int_repr_out_tt = _cast2 Unmanaged.int_repr_out_tt
+
+_make_per_tensor_quantized_tensor_out_ttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_make_per_tensor_quantized_tensor_out_ttdl = _cast4 Unmanaged._make_per_tensor_quantized_tensor_out_ttdl
+
+_make_per_channel_quantized_tensor_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_make_per_channel_quantized_tensor_out_ttttl = _cast5 Unmanaged._make_per_channel_quantized_tensor_out_ttttl
+
+fake_quantize_per_tensor_affine_cachemask_out_tttdlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+fake_quantize_per_tensor_affine_cachemask_out_tttdlll = _cast7 Unmanaged.fake_quantize_per_tensor_affine_cachemask_out_tttdlll
+
+_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out_ttttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out_ttttttll = _cast8 Unmanaged._fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out_ttttttll
+
+_fake_quantize_learnable_per_tensor_affine_out_ttttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_fake_quantize_learnable_per_tensor_affine_out_ttttlld = _cast7 Unmanaged._fake_quantize_learnable_per_tensor_affine_out_ttttlld
+
+_fake_quantize_learnable_per_tensor_affine_out_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_fake_quantize_learnable_per_tensor_affine_out_ttttll = _cast6 Unmanaged._fake_quantize_learnable_per_tensor_affine_out_ttttll
+
+fake_quantize_per_channel_affine_cachemask_out_tttttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+fake_quantize_per_channel_affine_cachemask_out_tttttlll = _cast8 Unmanaged.fake_quantize_per_channel_affine_cachemask_out_tttttlll
+
+_fake_quantize_learnable_per_channel_affine_out_ttttllld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_fake_quantize_learnable_per_channel_affine_out_ttttllld = _cast8 Unmanaged._fake_quantize_learnable_per_channel_affine_out_ttttllld
+
+_fake_quantize_learnable_per_channel_affine_out_ttttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_fake_quantize_learnable_per_channel_affine_out_ttttlll = _cast7 Unmanaged._fake_quantize_learnable_per_channel_affine_out_ttttlll
+
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlllbb = _cast15 Unmanaged._fused_moving_avg_obs_fq_helper_out_tttttttttdlllbb
+
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlllb = _cast14 Unmanaged._fused_moving_avg_obs_fq_helper_out_tttttttttdlllb
+
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlll = _cast13 Unmanaged._fused_moving_avg_obs_fq_helper_out_tttttttttdlll
+
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlllbb = _cast13 Unmanaged._fused_moving_avg_obs_fq_helper_functional_tttttttdlllbb
+
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlllb = _cast12 Unmanaged._fused_moving_avg_obs_fq_helper_functional_tttttttdlllb
+
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlll = _cast11 Unmanaged._fused_moving_avg_obs_fq_helper_functional_tttttttdlll
+
+_to_copy_out_ttbM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_to_copy_out_ttbM = _cast4 Unmanaged._to_copy_out_ttbM
+
+_to_copy_out_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_to_copy_out_ttb = _cast3 Unmanaged._to_copy_out_ttb
+
+_to_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_to_copy_out_tt = _cast2 Unmanaged._to_copy_out_tt
+
+_lstm_mps_out_tttttttllbldbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_lstm_mps_out_tttttttllbldbbb = _cast15 Unmanaged._lstm_mps_out_tttttttllbldbbb
+
+lstm_mps_backward_out_tlltttttttllbldbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (())
+lstm_mps_backward_out_tlltttttttllbldbbb = _cast18 Unmanaged.lstm_mps_backward_out_tlltttttttllbldbbb
+
+_thnn_fused_lstm_cell_out_tttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_out_tttttttt = _cast8 Unmanaged._thnn_fused_lstm_cell_out_tttttttt
+
+_thnn_fused_lstm_cell_out_ttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_out_ttttttt = _cast7 Unmanaged._thnn_fused_lstm_cell_out_ttttttt
+
+_thnn_fused_lstm_cell_out_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_out_tttttt = _cast6 Unmanaged._thnn_fused_lstm_cell_out_tttttt
+
+_thnn_fused_lstm_cell_backward_impl_out_ttttttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_backward_impl_out_ttttttttb = _cast9 Unmanaged._thnn_fused_lstm_cell_backward_impl_out_ttttttttb
+
+_thnn_fused_gru_cell_out_ttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_out_ttttttt = _cast7 Unmanaged._thnn_fused_gru_cell_out_ttttttt
+
+_thnn_fused_gru_cell_out_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_out_tttttt = _cast6 Unmanaged._thnn_fused_gru_cell_out_tttttt
+
+_thnn_fused_gru_cell_out_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_out_ttttt = _cast5 Unmanaged._thnn_fused_gru_cell_out_ttttt
+
+_thnn_fused_gru_cell_backward_out_tttttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_fused_gru_cell_backward_out_tttttttb = _cast8 Unmanaged._thnn_fused_gru_cell_backward_out_tttttttb
+
+_pack_padded_sequence_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_pack_padded_sequence_out_ttttb = _cast5 Unmanaged._pack_padded_sequence_out_ttttb
+
+set_out_ttS
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Storage
+  -> IO (ForeignPtr Tensor)
+set_out_ttS = _cast3 Unmanaged.set_out_ttS
+
+set_tS
+  :: ForeignPtr Tensor
+  -> ForeignPtr Storage
+  -> IO (ForeignPtr Tensor)
+set_tS = _cast2 Unmanaged.set_tS
+
+set_out_ttSlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Storage
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+set_out_ttSlll = _cast6 Unmanaged.set_out_ttSlll
+
+set_out_ttSll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Storage
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+set_out_ttSll = _cast5 Unmanaged.set_out_ttSll
+
+set_tSlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Storage
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+set_tSlll = _cast5 Unmanaged.set_tSlll
+
+set_tSll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Storage
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+set_tSll = _cast4 Unmanaged.set_tSll
+
+set_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+set_out_ttt = _cast3 Unmanaged.set_out_ttt
+
+set_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+set_tt = _cast2 Unmanaged.set_tt
+
+set_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+set_out_tt = _cast2 Unmanaged.set_out_tt
+
+set_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+set_t = _cast1 Unmanaged.set_t
+
+lift_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lift_out_tt = _cast2 Unmanaged.lift_out_tt
+
+lift_fresh_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lift_fresh_copy_out_tt = _cast2 Unmanaged.lift_fresh_copy_out_tt
+
+masked_fill_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+masked_fill_out_ttts = _cast4 Unmanaged.masked_fill_out_ttts
+
+masked_fill_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+masked_fill_out_tttt = _cast4 Unmanaged.masked_fill_out_tttt
+
+masked_scatter_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+masked_scatter_out_tttt = _cast4 Unmanaged.masked_scatter_out_tttt
+
+_masked_softmax_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_out_tttll = _cast5 Unmanaged._masked_softmax_out_tttll
+
+_masked_softmax_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_out_tttl = _cast4 Unmanaged._masked_softmax_out_tttl
+
+_masked_softmax_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_out_ttt = _cast3 Unmanaged._masked_softmax_out_ttt
+
+_masked_softmax_backward_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_backward_out_ttttl = _cast5 Unmanaged._masked_softmax_backward_out_ttttl
+
+_masked_softmax_backward_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_backward_out_tttt = _cast4 Unmanaged._masked_softmax_backward_out_tttt
+
+put_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+put_out_ttttb = _cast5 Unmanaged.put_out_ttttb
+
+put_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+put_out_tttt = _cast4 Unmanaged.put_out_tttt
+
+index_fill_out_ttlts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+index_fill_out_ttlts = _cast5 Unmanaged.index_fill_out_ttlts
+
+index_fill_out_ttltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_fill_out_ttltt = _cast5 Unmanaged.index_fill_out_ttltt
+
+bitwise_and_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_and_out_tst = _cast3 Unmanaged.bitwise_and_out_tst
+
+bitwise_or_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_or_out_tst = _cast3 Unmanaged.bitwise_or_out_tst
+
+bitwise_xor_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_xor_out_tst = _cast3 Unmanaged.bitwise_xor_out_tst
+
+__lshift___out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+__lshift___out_tts = _cast3 Unmanaged.__lshift___out_tts
+
+__lshift___out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+__lshift___out_ttt = _cast3 Unmanaged.__lshift___out_ttt
+
+bitwise_left_shift_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_left_shift_out_tst = _cast3 Unmanaged.bitwise_left_shift_out_tst
+
+__rshift___out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+__rshift___out_tts = _cast3 Unmanaged.__rshift___out_tts
+
+__rshift___out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+__rshift___out_ttt = _cast3 Unmanaged.__rshift___out_ttt
+
+bitwise_right_shift_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_right_shift_out_tst = _cast3 Unmanaged.bitwise_right_shift_out_tst
+
+random_out_ttllG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+random_out_ttllG = _cast5 Unmanaged.random_out_ttllG
+
+random_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+random_out_ttll = _cast4 Unmanaged.random_out_ttll
+
+random_tllG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+random_tllG = _cast4 Unmanaged.random_tllG
+
diff --git a/src/Torch/Internal/Managed/Native/Native15.hs b/src/Torch/Internal/Managed/Native/Native15.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native15.hs
@@ -0,0 +1,2280 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native15 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native15 as Unmanaged
+
+
+random_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+random_tll = _cast3 Unmanaged.random_tll
+
+random_out_ttlG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+random_out_ttlG = _cast4 Unmanaged.random_out_ttlG
+
+random_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+random_out_ttl = _cast3 Unmanaged.random_out_ttl
+
+random_tlG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+random_tlG = _cast3 Unmanaged.random_tlG
+
+random_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+random_tl = _cast2 Unmanaged.random_tl
+
+random_out_ttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+random_out_ttG = _cast3 Unmanaged.random_out_ttG
+
+random_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+random_out_tt = _cast2 Unmanaged.random_out_tt
+
+random_tG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+random_tG = _cast2 Unmanaged.random_tG
+
+random_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+random_t = _cast1 Unmanaged.random_t
+
+uniform_out_ttddG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+uniform_out_ttddG = _cast5 Unmanaged.uniform_out_ttddG
+
+uniform_out_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+uniform_out_ttdd = _cast4 Unmanaged.uniform_out_ttdd
+
+uniform_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+uniform_out_ttd = _cast3 Unmanaged.uniform_out_ttd
+
+uniform_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+uniform_out_tt = _cast2 Unmanaged.uniform_out_tt
+
+uniform_tddG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+uniform_tddG = _cast4 Unmanaged.uniform_tddG
+
+uniform_tdd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+uniform_tdd = _cast3 Unmanaged.uniform_tdd
+
+uniform_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+uniform_td = _cast2 Unmanaged.uniform_td
+
+uniform_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+uniform_t = _cast1 Unmanaged.uniform_t
+
+cauchy_out_ttddG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+cauchy_out_ttddG = _cast5 Unmanaged.cauchy_out_ttddG
+
+cauchy_out_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+cauchy_out_ttdd = _cast4 Unmanaged.cauchy_out_ttdd
+
+cauchy_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+cauchy_out_ttd = _cast3 Unmanaged.cauchy_out_ttd
+
+cauchy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cauchy_out_tt = _cast2 Unmanaged.cauchy_out_tt
+
+cauchy_tddG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+cauchy_tddG = _cast4 Unmanaged.cauchy_tddG
+
+cauchy_tdd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+cauchy_tdd = _cast3 Unmanaged.cauchy_tdd
+
+cauchy_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+cauchy_td = _cast2 Unmanaged.cauchy_td
+
+cauchy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cauchy_t = _cast1 Unmanaged.cauchy_t
+
+log_normal_out_ttddG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+log_normal_out_ttddG = _cast5 Unmanaged.log_normal_out_ttddG
+
+log_normal_out_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+log_normal_out_ttdd = _cast4 Unmanaged.log_normal_out_ttdd
+
+log_normal_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+log_normal_out_ttd = _cast3 Unmanaged.log_normal_out_ttd
+
+log_normal_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log_normal_out_tt = _cast2 Unmanaged.log_normal_out_tt
+
+log_normal_tddG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+log_normal_tddG = _cast4 Unmanaged.log_normal_tddG
+
+log_normal_tdd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+log_normal_tdd = _cast3 Unmanaged.log_normal_tdd
+
+log_normal_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+log_normal_td = _cast2 Unmanaged.log_normal_td
+
+log_normal_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log_normal_t = _cast1 Unmanaged.log_normal_t
+
+exponential_out_ttdG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+exponential_out_ttdG = _cast4 Unmanaged.exponential_out_ttdG
+
+exponential_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+exponential_out_ttd = _cast3 Unmanaged.exponential_out_ttd
+
+exponential_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+exponential_out_tt = _cast2 Unmanaged.exponential_out_tt
+
+exponential_tdG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+exponential_tdG = _cast3 Unmanaged.exponential_tdG
+
+exponential_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+exponential_td = _cast2 Unmanaged.exponential_td
+
+exponential_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+exponential_t = _cast1 Unmanaged.exponential_t
+
+geometric_out_ttdG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+geometric_out_ttdG = _cast4 Unmanaged.geometric_out_ttdG
+
+geometric_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+geometric_out_ttd = _cast3 Unmanaged.geometric_out_ttd
+
+geometric_tdG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+geometric_tdG = _cast3 Unmanaged.geometric_tdG
+
+geometric_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+geometric_td = _cast2 Unmanaged.geometric_td
+
+tril_indices_out_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tril_indices_out_tlll = _cast4 Unmanaged.tril_indices_out_tlll
+
+tril_indices_out_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tril_indices_out_tll = _cast3 Unmanaged.tril_indices_out_tll
+
+triu_indices_out_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triu_indices_out_tlll = _cast4 Unmanaged.triu_indices_out_tlll
+
+triu_indices_out_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triu_indices_out_tll = _cast3 Unmanaged.triu_indices_out_tll
+
+trace_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trace_out_tt = _cast2 Unmanaged.trace_out_tt
+
+_cholesky_solve_helper_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cholesky_solve_helper_out_tttb = _cast4 Unmanaged._cholesky_solve_helper_out_tttb
+
+dist_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+dist_out_ttts = _cast4 Unmanaged.dist_out_ttts
+
+dist_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+dist_out_ttt = _cast3 Unmanaged.dist_out_ttt
+
+_histogramdd_bin_edges_out_ltlatb
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (())
+_histogramdd_bin_edges_out_ltlatb = _cast6 Unmanaged._histogramdd_bin_edges_out_ltlatb
+
+_histogramdd_bin_edges_out_ltlat
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> IO (())
+_histogramdd_bin_edges_out_ltlat = _cast5 Unmanaged._histogramdd_bin_edges_out_ltlat
+
+_histogramdd_bin_edges_out_ltla
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (())
+_histogramdd_bin_edges_out_ltla = _cast4 Unmanaged._histogramdd_bin_edges_out_ltla
+
+_histogramdd_bin_edges_out_ltl
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+_histogramdd_bin_edges_out_ltl = _cast3 Unmanaged._histogramdd_bin_edges_out_ltl
+
+_histogramdd_from_bin_cts_out_ttlatb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_cts_out_ttlatb = _cast6 Unmanaged._histogramdd_from_bin_cts_out_ttlatb
+
+_histogramdd_from_bin_cts_out_ttlat
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_cts_out_ttlat = _cast5 Unmanaged._histogramdd_from_bin_cts_out_ttlat
+
+_histogramdd_from_bin_cts_out_ttla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_cts_out_ttla = _cast4 Unmanaged._histogramdd_from_bin_cts_out_ttla
+
+_histogramdd_from_bin_cts_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_cts_out_ttl = _cast3 Unmanaged._histogramdd_from_bin_cts_out_ttl
+
+_histogramdd_from_bin_tensors_out_ttltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_tensors_out_ttltb = _cast5 Unmanaged._histogramdd_from_bin_tensors_out_ttltb
+
+_histogramdd_from_bin_tensors_out_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_tensors_out_ttlt = _cast4 Unmanaged._histogramdd_from_bin_tensors_out_ttlt
+
+_histogramdd_from_bin_tensors_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_tensors_out_ttl = _cast3 Unmanaged._histogramdd_from_bin_tensors_out_ttl
+
+remainder_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+remainder_out_tst = _cast3 Unmanaged.remainder_out_tst
+
+argsort_out_ttblb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argsort_out_ttblb = _cast5 Unmanaged.argsort_out_ttblb
+
+argsort_out_ttbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+argsort_out_ttbl = _cast4 Unmanaged.argsort_out_ttbl
+
+argsort_out_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argsort_out_ttb = _cast3 Unmanaged.argsort_out_ttb
+
+unfold_backward_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+unfold_backward_out_ttllll = _cast6 Unmanaged.unfold_backward_out_ttllll
+
+normal_out_ttddG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_out_ttddG = _cast5 Unmanaged.normal_out_ttddG
+
+normal_out_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+normal_out_ttdd = _cast4 Unmanaged.normal_out_ttdd
+
+-- normal_out_ttd
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr Tensor
+--   -> CDouble
+--   -> IO (ForeignPtr Tensor)
+-- normal_out_ttd = _cast3 Unmanaged.normal_out_ttd
+
+-- normal_out_tt
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr Tensor
+--   -> IO (ForeignPtr Tensor)
+-- normal_out_tt = _cast2 Unmanaged.normal_out_tt
+
+_amp_foreach_non_finite_check_and_unscale_out_lltt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+_amp_foreach_non_finite_check_and_unscale_out_lltt = _cast4 Unmanaged._amp_foreach_non_finite_check_and_unscale_out_lltt
+
+_amp_foreach_non_finite_check_and_unscale_ltt
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(TensorList,Tensor)))
+_amp_foreach_non_finite_check_and_unscale_ltt = _cast3 Unmanaged._amp_foreach_non_finite_check_and_unscale_ltt
+
+_amp_update_scale_out_ttttddl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_amp_update_scale_out_ttttddl = _cast7 Unmanaged._amp_update_scale_out_ttttddl
+
+_amp_update_scale_tttddl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_amp_update_scale_tttddl = _cast6 Unmanaged._amp_update_scale_tttddl
+
+_foreach_add_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_add_out_lls = _cast3 Unmanaged._foreach_add_out_lls
+
+_foreach_sub_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_sub_out_lls = _cast3 Unmanaged._foreach_sub_out_lls
+
+_foreach_mul_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_mul_out_lls = _cast3 Unmanaged._foreach_mul_out_lls
+
+_foreach_div_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_div_out_lls = _cast3 Unmanaged._foreach_div_out_lls
+
+_foreach_clamp_min_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_clamp_min_out_lls = _cast3 Unmanaged._foreach_clamp_min_out_lls
+
+_foreach_clamp_max_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_clamp_max_out_lls = _cast3 Unmanaged._foreach_clamp_max_out_lls
+
+_foreach_maximum_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_maximum_out_lls = _cast3 Unmanaged._foreach_maximum_out_lls
+
+_foreach_minimum_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_minimum_out_lls = _cast3 Unmanaged._foreach_minimum_out_lls
+
+_foreach_add_out_llls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_add_out_llls = _cast4 Unmanaged._foreach_add_out_llls
+
+_foreach_add_out_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_add_out_lll = _cast3 Unmanaged._foreach_add_out_lll
+
+_foreach_sub_out_llls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_sub_out_llls = _cast4 Unmanaged._foreach_sub_out_llls
+
+_foreach_sub_out_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_sub_out_lll = _cast3 Unmanaged._foreach_sub_out_lll
+
+_foreach_mul_out_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_mul_out_lll = _cast3 Unmanaged._foreach_mul_out_lll
+
+_foreach_div_out_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_div_out_lll = _cast3 Unmanaged._foreach_div_out_lll
+
+_foreach_clamp_min_out_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_clamp_min_out_lll = _cast3 Unmanaged._foreach_clamp_min_out_lll
+
+_foreach_clamp_max_out_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_clamp_max_out_lll = _cast3 Unmanaged._foreach_clamp_max_out_lll
+
+_foreach_maximum_out_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_maximum_out_lll = _cast3 Unmanaged._foreach_maximum_out_lll
+
+_foreach_minimum_out_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_minimum_out_lll = _cast3 Unmanaged._foreach_minimum_out_lll
+
+_foreach_add_out_llA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_add_out_llA = _cast3 Unmanaged._foreach_add_out_llA
+
+_foreach_sub_out_llA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_sub_out_llA = _cast3 Unmanaged._foreach_sub_out_llA
+
+_foreach_div_out_llA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_div_out_llA = _cast3 Unmanaged._foreach_div_out_llA
+
+_foreach_mul_out_llA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_mul_out_llA = _cast3 Unmanaged._foreach_mul_out_llA
+
+_foreach_clamp_min_out_llA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_clamp_min_out_llA = _cast3 Unmanaged._foreach_clamp_min_out_llA
+
+_foreach_clamp_max_out_llA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_clamp_max_out_llA = _cast3 Unmanaged._foreach_clamp_max_out_llA
+
+_foreach_maximum_out_llA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_maximum_out_llA = _cast3 Unmanaged._foreach_maximum_out_llA
+
+_foreach_minimum_out_llA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_minimum_out_llA = _cast3 Unmanaged._foreach_minimum_out_llA
+
+_foreach_exp_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_exp_out_ll = _cast2 Unmanaged._foreach_exp_out_ll
+
+_foreach_zero_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_zero_out_ll = _cast2 Unmanaged._foreach_zero_out_ll
+
+_foreach_zero_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_zero_l = _cast1 Unmanaged._foreach_zero_l
+
+_foreach_sqrt_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_sqrt_out_ll = _cast2 Unmanaged._foreach_sqrt_out_ll
+
+_foreach_abs_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_abs_out_ll = _cast2 Unmanaged._foreach_abs_out_ll
+
+_foreach_acos_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_acos_out_ll = _cast2 Unmanaged._foreach_acos_out_ll
+
+_foreach_asin_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_asin_out_ll = _cast2 Unmanaged._foreach_asin_out_ll
+
+_foreach_atan_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_atan_out_ll = _cast2 Unmanaged._foreach_atan_out_ll
+
+_foreach_ceil_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_ceil_out_ll = _cast2 Unmanaged._foreach_ceil_out_ll
+
+_foreach_cos_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_cos_out_ll = _cast2 Unmanaged._foreach_cos_out_ll
+
+_foreach_cosh_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_cosh_out_ll = _cast2 Unmanaged._foreach_cosh_out_ll
+
+_foreach_erf_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_erf_out_ll = _cast2 Unmanaged._foreach_erf_out_ll
+
+_foreach_erfc_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_erfc_out_ll = _cast2 Unmanaged._foreach_erfc_out_ll
+
+_foreach_expm1_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_expm1_out_ll = _cast2 Unmanaged._foreach_expm1_out_ll
+
+_foreach_floor_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_floor_out_ll = _cast2 Unmanaged._foreach_floor_out_ll
+
+_foreach_log_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_log_out_ll = _cast2 Unmanaged._foreach_log_out_ll
+
+_foreach_log10_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_log10_out_ll = _cast2 Unmanaged._foreach_log10_out_ll
+
+_foreach_log1p_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_log1p_out_ll = _cast2 Unmanaged._foreach_log1p_out_ll
+
+_foreach_log2_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_log2_out_ll = _cast2 Unmanaged._foreach_log2_out_ll
+
+_foreach_neg_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_neg_out_ll = _cast2 Unmanaged._foreach_neg_out_ll
+
+_foreach_tan_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_tan_out_ll = _cast2 Unmanaged._foreach_tan_out_ll
+
+_foreach_tanh_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_tanh_out_ll = _cast2 Unmanaged._foreach_tanh_out_ll
+
+_foreach_sin_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_sin_out_ll = _cast2 Unmanaged._foreach_sin_out_ll
+
+_foreach_sinh_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_sinh_out_ll = _cast2 Unmanaged._foreach_sinh_out_ll
+
+_foreach_round_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_round_out_ll = _cast2 Unmanaged._foreach_round_out_ll
+
+_foreach_lgamma_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_lgamma_out_ll = _cast2 Unmanaged._foreach_lgamma_out_ll
+
+_foreach_frac_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_frac_out_ll = _cast2 Unmanaged._foreach_frac_out_ll
+
+_foreach_reciprocal_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_reciprocal_out_ll = _cast2 Unmanaged._foreach_reciprocal_out_ll
+
+_foreach_sigmoid_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_sigmoid_out_ll = _cast2 Unmanaged._foreach_sigmoid_out_ll
+
+_foreach_trunc_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_trunc_out_ll = _cast2 Unmanaged._foreach_trunc_out_ll
+
+_foreach_addcdiv_out_lllls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_addcdiv_out_lllls = _cast5 Unmanaged._foreach_addcdiv_out_lllls
+
+_foreach_addcdiv_out_llll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_addcdiv_out_llll = _cast4 Unmanaged._foreach_addcdiv_out_llll
+
+_foreach_addcmul_out_lllls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_addcmul_out_lllls = _cast5 Unmanaged._foreach_addcmul_out_lllls
+
+_foreach_addcmul_out_llll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_addcmul_out_llll = _cast4 Unmanaged._foreach_addcmul_out_llll
+
+_foreach_addcdiv_out_llllA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_addcdiv_out_llllA = _cast5 Unmanaged._foreach_addcdiv_out_llllA
+
+_foreach_addcdiv_out_llllt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (())
+_foreach_addcdiv_out_llllt = _cast5 Unmanaged._foreach_addcdiv_out_llllt
+
+_foreach_addcmul_out_llllA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_addcmul_out_llllA = _cast5 Unmanaged._foreach_addcmul_out_llllA
+
+_foreach_addcmul_out_llllt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (())
+_foreach_addcmul_out_llllt = _cast5 Unmanaged._foreach_addcmul_out_llllt
+
+_foreach_norm_out_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_norm_out_lls = _cast3 Unmanaged._foreach_norm_out_lls
+
+_foreach_norm_out_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_norm_out_ll = _cast2 Unmanaged._foreach_norm_out_ll
+
+_foreach_lerp_out_llll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_lerp_out_llll = _cast4 Unmanaged._foreach_lerp_out_llll
+
+_foreach_lerp_out_llls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_lerp_out_llls = _cast4 Unmanaged._foreach_lerp_out_llls
+
+bucketize_out_tstbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bucketize_out_tstbb = _cast5 Unmanaged.bucketize_out_tstbb
+
+bucketize_out_tstb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bucketize_out_tstb = _cast4 Unmanaged.bucketize_out_tstb
+
+bucketize_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bucketize_out_tst = _cast3 Unmanaged.bucketize_out_tst
+
+searchsorted_out_ttsbbst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_ttsbbst = _cast7 Unmanaged.searchsorted_out_ttsbbst
+
+searchsorted_out_ttsbbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_ttsbbs = _cast6 Unmanaged.searchsorted_out_ttsbbs
+
+searchsorted_out_ttsbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_ttsbb = _cast5 Unmanaged.searchsorted_out_ttsbb
+
+searchsorted_out_ttsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_ttsb = _cast4 Unmanaged.searchsorted_out_ttsb
+
+searchsorted_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_tts = _cast3 Unmanaged.searchsorted_out_tts
+
+glu_jvp_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+glu_jvp_out_ttttl = _cast5 Unmanaged.glu_jvp_out_ttttl
+
+glu_backward_jvp_out_ttttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+glu_backward_jvp_out_ttttttl = _cast7 Unmanaged.glu_backward_jvp_out_ttttttl
+
+hardswish_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardswish_backward_out_ttt = _cast3 Unmanaged.hardswish_backward_out_ttt
+
+rrelu_with_noise_backward_out_ttttssbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_backward_out_ttttssbb = _cast8 Unmanaged.rrelu_with_noise_backward_out_ttttssbb
+
+mkldnn_adaptive_avg_pool2d_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_adaptive_avg_pool2d_backward_out_ttt = _cast3 Unmanaged.mkldnn_adaptive_avg_pool2d_backward_out_ttt
+
+_adaptive_avg_pool2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_adaptive_avg_pool2d_out_ttl = _cast3 Unmanaged._adaptive_avg_pool2d_out_ttl
+
+_adaptive_avg_pool2d_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_adaptive_avg_pool2d_backward_out_ttt = _cast3 Unmanaged._adaptive_avg_pool2d_backward_out_ttt
+
+_adaptive_avg_pool3d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_adaptive_avg_pool3d_out_ttl = _cast3 Unmanaged._adaptive_avg_pool3d_out_ttl
+
+_adaptive_avg_pool3d_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_adaptive_avg_pool3d_backward_out_ttt = _cast3 Unmanaged._adaptive_avg_pool3d_backward_out_ttt
+
+_slow_conv2d_backward_out_ttttttllla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_slow_conv2d_backward_out_ttttttllla = _cast10 Unmanaged._slow_conv2d_backward_out_ttttttllla
+
+conv_depthwise3d_out_tttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+conv_depthwise3d_out_tttltlll = _cast8 Unmanaged.conv_depthwise3d_out_tttltlll
+
+slow_conv_dilated2d_out_tttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_out_tttltlll = _cast8 Unmanaged.slow_conv_dilated2d_out_tttltlll
+
+slow_conv_dilated2d_out_tttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_out_tttltll = _cast7 Unmanaged.slow_conv_dilated2d_out_tttltll
+
+slow_conv_dilated2d_out_tttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_out_tttltl = _cast6 Unmanaged.slow_conv_dilated2d_out_tttltl
+
+slow_conv_dilated2d_out_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_out_tttlt = _cast5 Unmanaged.slow_conv_dilated2d_out_tttlt
+
+slow_conv_dilated2d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated2d_out_tttl = _cast4 Unmanaged.slow_conv_dilated2d_out_tttl
+
+slow_conv_dilated3d_out_tttltlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_out_tttltlll = _cast8 Unmanaged.slow_conv_dilated3d_out_tttltlll
+
+slow_conv_dilated3d_out_tttltll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_out_tttltll = _cast7 Unmanaged.slow_conv_dilated3d_out_tttltll
+
+slow_conv_dilated3d_out_tttltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_out_tttltl = _cast6 Unmanaged.slow_conv_dilated3d_out_tttltl
+
+slow_conv_dilated3d_out_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_out_tttlt = _cast5 Unmanaged.slow_conv_dilated3d_out_tttlt
+
+slow_conv_dilated3d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+slow_conv_dilated3d_out_tttl = _cast4 Unmanaged.slow_conv_dilated3d_out_tttl
+
+isinf_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isinf_out_tt = _cast2 Unmanaged.isinf_out_tt
+
+linalg_matrix_exp_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_matrix_exp_out_tt = _cast2 Unmanaged.linalg_matrix_exp_out_tt
+
+_test_optional_intlist_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_test_optional_intlist_out_ttl = _cast3 Unmanaged._test_optional_intlist_out_ttl
+
+_test_optional_filled_intlist_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_test_optional_filled_intlist_out_ttl = _cast3 Unmanaged._test_optional_filled_intlist_out_ttl
+
+_test_optional_floatlist_out_tta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_test_optional_floatlist_out_tta = _cast3 Unmanaged._test_optional_floatlist_out_tta
+
+_test_warn_in_autograd_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_warn_in_autograd_out_tt = _cast2 Unmanaged._test_warn_in_autograd_out_tt
+
+_test_autograd_multiple_dispatch_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_autograd_multiple_dispatch_out_tt = _cast2 Unmanaged._test_autograd_multiple_dispatch_out_tt
+
+_test_autograd_multiple_dispatch_view_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_test_autograd_multiple_dispatch_view_copy_out_tt = _cast2 Unmanaged._test_autograd_multiple_dispatch_view_copy_out_tt
+
+segment_reduce_out_ttstttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+segment_reduce_out_ttstttlbs = _cast9 Unmanaged.segment_reduce_out_ttstttlbs
+
+segment_reduce_out_ttstttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+segment_reduce_out_ttstttlb = _cast8 Unmanaged.segment_reduce_out_ttstttlb
+
+segment_reduce_out_ttstttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+segment_reduce_out_ttstttl = _cast7 Unmanaged.segment_reduce_out_ttstttl
+
+segment_reduce_out_ttsttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+segment_reduce_out_ttsttt = _cast6 Unmanaged.segment_reduce_out_ttsttt
+
+segment_reduce_out_ttstt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+segment_reduce_out_ttstt = _cast5 Unmanaged.segment_reduce_out_ttstt
+
+segment_reduce_out_ttst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+segment_reduce_out_ttst = _cast4 Unmanaged.segment_reduce_out_ttst
+
+segment_reduce_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+segment_reduce_out_tts = _cast3 Unmanaged.segment_reduce_out_tts
+
+_segment_reduce_backward_out_ttttsttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_out_ttttsttls = _cast9 Unmanaged._segment_reduce_backward_out_ttttsttls
+
+_segment_reduce_backward_out_ttttsttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_out_ttttsttl = _cast8 Unmanaged._segment_reduce_backward_out_ttttsttl
+
+_segment_reduce_backward_out_ttttstt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_out_ttttstt = _cast7 Unmanaged._segment_reduce_backward_out_ttttstt
+
+_segment_reduce_backward_out_ttttst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_out_ttttst = _cast6 Unmanaged._segment_reduce_backward_out_ttttst
+
+_segment_reduce_backward_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+_segment_reduce_backward_out_tttts = _cast5 Unmanaged._segment_reduce_backward_out_tttts
+
+_nested_tensor_from_tensor_list_out_tlsLDb
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ScalarType
+  -> Layout
+  -> DeviceType
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_out_tlsLDb = _cast6 Unmanaged._nested_tensor_from_tensor_list_out_tlsLDb
+
+_nested_tensor_from_tensor_list_out_tlsLD
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ScalarType
+  -> Layout
+  -> DeviceType
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_out_tlsLD = _cast5 Unmanaged._nested_tensor_from_tensor_list_out_tlsLD
+
+_nested_tensor_from_tensor_list_out_tlsL
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ScalarType
+  -> Layout
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_out_tlsL = _cast4 Unmanaged._nested_tensor_from_tensor_list_out_tlsL
+
+_nested_tensor_from_tensor_list_out_tls
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_out_tls = _cast3 Unmanaged._nested_tensor_from_tensor_list_out_tls
+
+_nested_tensor_from_tensor_list_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_tensor_list_out_tl = _cast2 Unmanaged._nested_tensor_from_tensor_list_out_tl
+
+_fw_primal_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_fw_primal_copy_out_ttl = _cast3 Unmanaged._fw_primal_copy_out_ttl
+
+_make_dual_copy_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_make_dual_copy_out_tttl = _cast4 Unmanaged._make_dual_copy_out_tttl
+
+view_as_real_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+view_as_real_copy_out_tt = _cast2 Unmanaged.view_as_real_copy_out_tt
+
+view_as_complex_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+view_as_complex_copy_out_tt = _cast2 Unmanaged.view_as_complex_copy_out_tt
+
+_conj_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_conj_copy_out_tt = _cast2 Unmanaged._conj_copy_out_tt
+
+_neg_view_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_neg_view_copy_out_tt = _cast2 Unmanaged._neg_view_copy_out_tt
+
+as_strided_copy_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+as_strided_copy_out_ttlll = _cast5 Unmanaged.as_strided_copy_out_ttlll
+
+as_strided_copy_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+as_strided_copy_out_ttll = _cast4 Unmanaged.as_strided_copy_out_ttll
+
+_sparse_broadcast_to_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_broadcast_to_copy_out_ttl = _cast3 Unmanaged._sparse_broadcast_to_copy_out_ttl
+
+diagonal_copy_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_copy_out_ttlll = _cast5 Unmanaged.diagonal_copy_out_ttlll
+
+diagonal_copy_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_copy_out_ttll = _cast4 Unmanaged.diagonal_copy_out_ttll
+
+diagonal_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_copy_out_ttl = _cast3 Unmanaged.diagonal_copy_out_ttl
+
+diagonal_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diagonal_copy_out_tt = _cast2 Unmanaged.diagonal_copy_out_tt
+
+expand_copy_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+expand_copy_out_ttlb = _cast4 Unmanaged.expand_copy_out_ttlb
+
+expand_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+expand_copy_out_ttl = _cast3 Unmanaged.expand_copy_out_ttl
+
+permute_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+permute_copy_out_ttl = _cast3 Unmanaged.permute_copy_out_ttl
+
+_reshape_alias_copy_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_reshape_alias_copy_out_ttll = _cast4 Unmanaged._reshape_alias_copy_out_ttll
+
+select_copy_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+select_copy_out_ttll = _cast4 Unmanaged.select_copy_out_ttll
+
+detach_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+detach_copy_out_tt = _cast2 Unmanaged.detach_copy_out_tt
+
+slice_copy_out_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_copy_out_ttllll = _cast6 Unmanaged.slice_copy_out_ttllll
+
+slice_copy_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_copy_out_ttlll = _cast5 Unmanaged.slice_copy_out_ttlll
+
+slice_copy_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_copy_out_ttll = _cast4 Unmanaged.slice_copy_out_ttll
+
+slice_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_copy_out_ttl = _cast3 Unmanaged.slice_copy_out_ttl
+
+slice_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slice_copy_out_tt = _cast2 Unmanaged.slice_copy_out_tt
+
+squeeze_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+squeeze_copy_out_tt = _cast2 Unmanaged.squeeze_copy_out_tt
+
+squeeze_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+squeeze_copy_out_ttl = _cast3 Unmanaged.squeeze_copy_out_ttl
+
+t_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+t_copy_out_tt = _cast2 Unmanaged.t_copy_out_tt
+
+transpose_copy_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+transpose_copy_out_ttll = _cast4 Unmanaged.transpose_copy_out_ttll
+
+unsqueeze_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+unsqueeze_copy_out_ttl = _cast3 Unmanaged.unsqueeze_copy_out_ttl
+
+_indices_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_indices_copy_out_tt = _cast2 Unmanaged._indices_copy_out_tt
+
+_values_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_values_copy_out_tt = _cast2 Unmanaged._values_copy_out_tt
+
+indices_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+indices_copy_out_tt = _cast2 Unmanaged.indices_copy_out_tt
+
+values_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+values_copy_out_tt = _cast2 Unmanaged.values_copy_out_tt
+
+crow_indices_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+crow_indices_copy_out_tt = _cast2 Unmanaged.crow_indices_copy_out_tt
+
+col_indices_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+col_indices_copy_out_tt = _cast2 Unmanaged.col_indices_copy_out_tt
+
+ccol_indices_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ccol_indices_copy_out_tt = _cast2 Unmanaged.ccol_indices_copy_out_tt
+
+row_indices_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+row_indices_copy_out_tt = _cast2 Unmanaged.row_indices_copy_out_tt
+
+view_copy_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+view_copy_out_ttl = _cast3 Unmanaged.view_copy_out_ttl
+
+view_copy_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+view_copy_out_tts = _cast3 Unmanaged.view_copy_out_tts
+
+unfold_copy_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+unfold_copy_out_ttlll = _cast5 Unmanaged.unfold_copy_out_ttlll
+
+alias_copy_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+alias_copy_out_tt = _cast2 Unmanaged.alias_copy_out_tt
+
+to_padded_tensor_out_ttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+to_padded_tensor_out_ttdl = _cast4 Unmanaged.to_padded_tensor_out_ttdl
+
+to_padded_tensor_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+to_padded_tensor_out_ttd = _cast3 Unmanaged.to_padded_tensor_out_ttd
+
+_transformer_encoder_layer_fwd_out_ttllttttbbdtttttttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_transformer_encoder_layer_fwd_out_ttllttttbbdtttttttttl = _cast21 Unmanaged._transformer_encoder_layer_fwd_out_ttllttttbbdtttttttttl
+
+_transformer_encoder_layer_fwd_out_ttllttttbbdttttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_transformer_encoder_layer_fwd_out_ttllttttbbdttttttttt = _cast20 Unmanaged._transformer_encoder_layer_fwd_out_ttllttttbbdttttttttt
+
+_transformer_encoder_layer_fwd_out_ttllttttbbdtttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_transformer_encoder_layer_fwd_out_ttllttttbbdtttttttt = _cast19 Unmanaged._transformer_encoder_layer_fwd_out_ttllttttbbdtttttttt
+
+_native_multi_head_attention_out_tttttlltttttbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttlltttttbbl = _cast15 Unmanaged._native_multi_head_attention_out_tttttlltttttbbl
+
+_native_multi_head_attention_out_tttttlltttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttlltttttbb = _cast14 Unmanaged._native_multi_head_attention_out_tttttlltttttbb
+
+_native_multi_head_attention_out_tttttlltttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttlltttttb = _cast13 Unmanaged._native_multi_head_attention_out_tttttlltttttb
+
+_native_multi_head_attention_out_tttttllttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttllttttt = _cast12 Unmanaged._native_multi_head_attention_out_tttttllttttt
+
+_native_multi_head_attention_out_tttttlltttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttlltttt = _cast11 Unmanaged._native_multi_head_attention_out_tttttlltttt
+
+_triton_scaled_dot_attention_out_ttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_triton_scaled_dot_attention_out_ttttd = _cast5 Unmanaged._triton_scaled_dot_attention_out_ttttd
+
+_triton_scaled_dot_attention_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_triton_scaled_dot_attention_out_tttt = _cast4 Unmanaged._triton_scaled_dot_attention_out_tttt
+
+_triton_multi_head_attention_out_ttttllttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_triton_multi_head_attention_out_ttttllttttt = _cast11 Unmanaged._triton_multi_head_attention_out_ttttllttttt
+
+_triton_multi_head_attention_out_ttttlltttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_triton_multi_head_attention_out_ttttlltttt = _cast10 Unmanaged._triton_multi_head_attention_out_ttttlltttt
+
+_foobar_out_ttbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_foobar_out_ttbbb = _cast5 Unmanaged._foobar_out_ttbbb
+
+_foobar_out_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_foobar_out_ttbb = _cast4 Unmanaged._foobar_out_ttbb
+
+_foobar_out_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_foobar_out_ttb = _cast3 Unmanaged._foobar_out_ttb
+
+_foobar_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_foobar_out_tt = _cast2 Unmanaged._foobar_out_tt
+
+_fused_adam_out_llllllldddddbbtt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+_fused_adam_out_llllllldddddbbtt = _cast16 Unmanaged._fused_adam_out_llllllldddddbbtt
+
+_fused_adam_out_llllllldddddbbt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (())
+_fused_adam_out_llllllldddddbbt = _cast15 Unmanaged._fused_adam_out_llllllldddddbbt
+
+_fused_adam_out_llllllldddddbb
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (())
+_fused_adam_out_llllllldddddbb = _cast14 Unmanaged._fused_adam_out_llllllldddddbb
+
+_fused_adam_lllllldddddbbtt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adam_lllllldddddbbtt = _cast15 Unmanaged._fused_adam_lllllldddddbbtt
+
+_fused_adam_lllllldddddbbt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adam_lllllldddddbbt = _cast14 Unmanaged._fused_adam_lllllldddddbbt
+
+_fused_adam_lllllldddddbb
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adam_lllllldddddbb = _cast13 Unmanaged._fused_adam_lllllldddddbb
+
+_fused_adamw_out_llllllldddddbbtt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+_fused_adamw_out_llllllldddddbbtt = _cast16 Unmanaged._fused_adamw_out_llllllldddddbbtt
+
+_fused_adamw_out_llllllldddddbbt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (())
+_fused_adamw_out_llllllldddddbbt = _cast15 Unmanaged._fused_adamw_out_llllllldddddbbt
+
+_fused_adamw_out_llllllldddddbb
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (())
+_fused_adamw_out_llllllldddddbb = _cast14 Unmanaged._fused_adamw_out_llllllldddddbb
+
+_fused_adamw_lllllldddddbbtt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adamw_lllllldddddbbtt = _cast15 Unmanaged._fused_adamw_lllllldddddbbtt
+
+_fused_adamw_lllllldddddbbt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adamw_lllllldddddbbt = _cast14 Unmanaged._fused_adamw_lllllldddddbbt
+
+_fused_adamw_lllllldddddbb
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adamw_lllllldddddbb = _cast13 Unmanaged._fused_adamw_lllllldddddbb
+
diff --git a/src/Torch/Internal/Managed/Native/Native2.hs b/src/Torch/Internal/Managed/Native/Native2.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native2.hs
@@ -0,0 +1,2167 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native2 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native2 as Unmanaged
+
+
+embedding_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+embedding_ttl = _cast3 Unmanaged.embedding_ttl
+
+embedding_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+embedding_tt = _cast2 Unmanaged.embedding_tt
+
+embedding_backward_ttllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+embedding_backward_ttllbb = _cast6 Unmanaged.embedding_backward_ttllbb
+
+embedding_dense_backward_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+embedding_dense_backward_ttllb = _cast5 Unmanaged.embedding_dense_backward_ttllb
+
+embedding_renorm__ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+embedding_renorm__ttdd = _cast4 Unmanaged.embedding_renorm__ttdd
+
+embedding_sparse_backward_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+embedding_sparse_backward_ttllb = _cast5 Unmanaged.embedding_sparse_backward_ttllb
+
+_embedding_bag_forward_only_tttblbtbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttblbtbl = _cast9 Unmanaged._embedding_bag_forward_only_tttblbtbl
+
+_embedding_bag_forward_only_tttblbtb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttblbtb = _cast8 Unmanaged._embedding_bag_forward_only_tttblbtb
+
+_embedding_bag_forward_only_tttblbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttblbt = _cast7 Unmanaged._embedding_bag_forward_only_tttblbt
+
+_embedding_bag_forward_only_tttblb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttblb = _cast6 Unmanaged._embedding_bag_forward_only_tttblb
+
+_embedding_bag_forward_only_tttbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttbl = _cast5 Unmanaged._embedding_bag_forward_only_tttbl
+
+_embedding_bag_forward_only_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttb = _cast4 Unmanaged._embedding_bag_forward_only_tttb
+
+_embedding_bag_forward_only_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_ttt = _cast3 Unmanaged._embedding_bag_forward_only_ttt
+
+_rowwise_prune_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_rowwise_prune_tts = _cast3 Unmanaged._rowwise_prune_tts
+
+row_stack_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+row_stack_l = _cast1 Unmanaged.row_stack_l
+
+row_stack_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+row_stack_out_tl = _cast2 Unmanaged.row_stack_out_tl
+
+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
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttblbt = _cast7 Unmanaged.embedding_bag_tttblbt
+
+embedding_bag_tttblb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttblb = _cast6 Unmanaged.embedding_bag_tttblb
+
+embedding_bag_tttbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttbl = _cast5 Unmanaged.embedding_bag_tttbl
+
+embedding_bag_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttb = _cast4 Unmanaged.embedding_bag_tttb
+
+embedding_bag_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_ttt = _cast3 Unmanaged.embedding_bag_ttt
+
+embedding_bag_tttblbtbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttblbtbl = _cast9 Unmanaged.embedding_bag_tttblbtbl
+
+_embedding_bag_tttblbtbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttblbtbl = _cast9 Unmanaged._embedding_bag_tttblbtbl
+
+_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
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttblbt = _cast7 Unmanaged._embedding_bag_tttblbt
+
+_embedding_bag_tttblb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttblb = _cast6 Unmanaged._embedding_bag_tttblb
+
+_embedding_bag_tttbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttbl = _cast5 Unmanaged._embedding_bag_tttbl
+
+_embedding_bag_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttb = _cast4 Unmanaged._embedding_bag_tttb
+
+_embedding_bag_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_ttt = _cast3 Unmanaged._embedding_bag_ttt
+
+_embedding_bag_backward_ttttttlblbtl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_backward_ttttttlblbtl = _cast12 Unmanaged._embedding_bag_backward_ttttttlblbtl
+
+_embedding_bag_backward_ttttttlblbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_backward_ttttttlblbt = _cast11 Unmanaged._embedding_bag_backward_ttttttlblbt
+
+_embedding_bag_sparse_backward_tttttlbltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_sparse_backward_tttttlbltl = _cast10 Unmanaged._embedding_bag_sparse_backward_tttttlbltl
+
+_embedding_bag_sparse_backward_tttttlblt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_sparse_backward_tttttlblt = _cast9 Unmanaged._embedding_bag_sparse_backward_tttttlblt
+
+_embedding_bag_dense_backward_tttttlbltl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_dense_backward_tttttlbltl = _cast10 Unmanaged._embedding_bag_dense_backward_tttttlbltl
+
+_embedding_bag_dense_backward_tttttlblt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_dense_backward_tttttlblt = _cast9 Unmanaged._embedding_bag_dense_backward_tttttlblt
+
+_embedding_bag_per_sample_weights_backward_tttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_per_sample_weights_backward_tttttll = _cast7 Unmanaged._embedding_bag_per_sample_weights_backward_tttttll
+
+_embedding_bag_per_sample_weights_backward_tttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_embedding_bag_per_sample_weights_backward_tttttl = _cast6 Unmanaged._embedding_bag_per_sample_weights_backward_tttttl
+
+empty_lNoM
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_lNoM = _cast4 Unmanaged.empty_lNoM
+
+empty_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+empty_lNo = _cast3 Unmanaged.empty_lNo
+
+empty_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+empty_lN = _cast2 Unmanaged.empty_lN
+
+empty_loM
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_loM = _cast3 Unmanaged.empty_loM
+
+empty_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+empty_lo = _cast2 Unmanaged.empty_lo
+
+empty_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+empty_l = _cast1 Unmanaged.empty_l
+
+_empty_affine_quantized_lodlM
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> CDouble
+  -> Int64
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_lodlM = _cast5 Unmanaged._empty_affine_quantized_lodlM
+
+_empty_affine_quantized_lodl
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_lodl = _cast4 Unmanaged._empty_affine_quantized_lodl
+
+_empty_affine_quantized_lod
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_lod = _cast3 Unmanaged._empty_affine_quantized_lod
+
+_empty_affine_quantized_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_lo = _cast2 Unmanaged._empty_affine_quantized_lo
+
+_empty_affine_quantized_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_l = _cast1 Unmanaged._empty_affine_quantized_l
+
+_empty_per_channel_affine_quantized_lttloM
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_empty_per_channel_affine_quantized_lttloM = _cast6 Unmanaged._empty_per_channel_affine_quantized_lttloM
+
+_empty_per_channel_affine_quantized_lttlo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_empty_per_channel_affine_quantized_lttlo = _cast5 Unmanaged._empty_per_channel_affine_quantized_lttlo
+
+_empty_per_channel_affine_quantized_lttl
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_empty_per_channel_affine_quantized_lttl = _cast4 Unmanaged._empty_per_channel_affine_quantized_lttl
+
+_resize_output__tlD
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> DeviceType
+  -> IO (ForeignPtr Tensor)
+_resize_output__tlD = _cast3 Unmanaged._resize_output__tlD
+
+empty_quantized_ltoM
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_quantized_ltoM = _cast4 Unmanaged.empty_quantized_ltoM
+
+empty_quantized_lto
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+empty_quantized_lto = _cast3 Unmanaged.empty_quantized_lto
+
+empty_quantized_lt
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+empty_quantized_lt = _cast2 Unmanaged.empty_quantized_lt
+
+empty_out_tlM
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_out_tlM = _cast3 Unmanaged.empty_out_tlM
+
+empty_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+empty_out_tl = _cast2 Unmanaged.empty_out_tl
+
+empty_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_like_toM = _cast3 Unmanaged.empty_like_toM
+
+empty_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+empty_strided_llo = _cast3 Unmanaged.empty_strided_llo
+
+empty_strided_ll
+  :: ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+empty_strided_ll = _cast2 Unmanaged.empty_strided_ll
+
+erf_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+erf_t = _cast1 Unmanaged.erf_t
+
+erf__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+erf__t = _cast1 Unmanaged.erf__t
+
+erf_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+erf_out_tt = _cast2 Unmanaged.erf_out_tt
+
+erfc_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+erfc_t = _cast1 Unmanaged.erfc_t
+
+erfc__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+erfc__t = _cast1 Unmanaged.erfc__t
+
+erfc_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+erfc_out_tt = _cast2 Unmanaged.erfc_out_tt
+
+exp_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+exp_t = _cast1 Unmanaged.exp_t
+
+exp__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+exp__t = _cast1 Unmanaged.exp__t
+
+exp_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+exp_out_tt = _cast2 Unmanaged.exp_out_tt
+
+exp2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+exp2_t = _cast1 Unmanaged.exp2_t
+
+exp2__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+exp2__t = _cast1 Unmanaged.exp2__t
+
+exp2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+exp2_out_tt = _cast2 Unmanaged.exp2_out_tt
+
+expm1_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+expm1_t = _cast1 Unmanaged.expm1_t
+
+expm1__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+expm1__t = _cast1 Unmanaged.expm1__t
+
+expm1_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+expm1_out_tt = _cast2 Unmanaged.expm1_out_tt
+
+eye_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+eye_lo = _cast2 Unmanaged.eye_lo
+
+eye_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+eye_l = _cast1 Unmanaged.eye_l
+
+eye_llo
+  :: Int64
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+eye_llo = _cast3 Unmanaged.eye_llo
+
+eye_ll
+  :: Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+eye_ll = _cast2 Unmanaged.eye_ll
+
+eye_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+eye_out_tl = _cast2 Unmanaged.eye_out_tl
+
+eye_out_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+eye_out_tll = _cast3 Unmanaged.eye_out_tll
+
+flatten_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+flatten_tll = _cast3 Unmanaged.flatten_tll
+
+flatten_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+flatten_tl = _cast2 Unmanaged.flatten_tl
+
+flatten_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+flatten_t = _cast1 Unmanaged.flatten_t
+
+flatten_tlln
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+flatten_tlln = _cast4 Unmanaged.flatten_tlln
+
+flatten_tnnn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+flatten_tnnn = _cast4 Unmanaged.flatten_tnnn
+
+flatten_tNn
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+flatten_tNn = _cast3 Unmanaged.flatten_tNn
+
+unflatten_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+unflatten_tll = _cast3 Unmanaged.unflatten_tll
+
+unflatten_tnlN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+unflatten_tnlN = _cast4 Unmanaged.unflatten_tnlN
+
+fill_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+fill_ts = _cast2 Unmanaged.fill_ts
+
+fill_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fill_tt = _cast2 Unmanaged.fill_tt
+
+fill__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+fill__ts = _cast2 Unmanaged.fill__ts
+
+fill__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fill__tt = _cast2 Unmanaged.fill__tt
+
+floor_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+floor_t = _cast1 Unmanaged.floor_t
+
+floor__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+floor__t = _cast1 Unmanaged.floor__t
+
+floor_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> 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)
+frac_t = _cast1 Unmanaged.frac_t
+
+frac__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+frac__t = _cast1 Unmanaged.frac__t
+
+frac_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+frac_out_tt = _cast2 Unmanaged.frac_out_tt
+
+full_lsNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+full_lsNo = _cast4 Unmanaged.full_lsNo
+
+full_lsN
+  :: ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+full_lsN = _cast3 Unmanaged.full_lsN
+
+full_lso
+  :: ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+full_lso = _cast3 Unmanaged.full_lso
+
+full_ls
+  :: ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+full_ls = _cast2 Unmanaged.full_ls
+
+full_out_tls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+full_out_tls = _cast3 Unmanaged.full_out_tls
+
+full_like_tsoM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+full_like_tsoM = _cast4 Unmanaged.full_like_tsoM
+
+full_like_tso
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+from_file_sblo = _cast4 Unmanaged.from_file_sblo
+
+from_file_sbl
+  :: ForeignPtr StdString
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+from_file_sbl = _cast3 Unmanaged.from_file_sbl
+
+from_file_sb
+  :: ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+from_file_sb = _cast2 Unmanaged.from_file_sb
+
+from_file_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+from_file_s = _cast1 Unmanaged.from_file_s
+
+gcd_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gcd_out_ttt = _cast3 Unmanaged.gcd_out_ttt
+
+gcd_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gcd_tt = _cast2 Unmanaged.gcd_tt
+
+gcd__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gcd__tt = _cast2 Unmanaged.gcd__tt
+
+lcm_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lcm_out_ttt = _cast3 Unmanaged.lcm_out_ttt
+
+lcm_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lcm_tt = _cast2 Unmanaged.lcm_tt
+
+lcm__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lcm__tt = _cast2 Unmanaged.lcm__tt
+
+grid_sampler_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+grid_sampler_ttllb = _cast5 Unmanaged.grid_sampler_ttllb
+
+grid_sampler_2d_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+grid_sampler_2d_ttllb = _cast5 Unmanaged.grid_sampler_2d_ttllb
+
+grid_sampler_2d_backward_tttllba
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+grid_sampler_2d_backward_tttllba = _cast7 Unmanaged.grid_sampler_2d_backward_tttllba
+
+_grid_sampler_2d_cpu_fallback_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_grid_sampler_2d_cpu_fallback_ttllb = _cast5 Unmanaged._grid_sampler_2d_cpu_fallback_ttllb
+
+_grid_sampler_2d_cpu_fallback_backward_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_grid_sampler_2d_cpu_fallback_backward_tttllb = _cast6 Unmanaged._grid_sampler_2d_cpu_fallback_backward_tttllb
+
+grid_sampler_3d_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+grid_sampler_3d_ttllb = _cast5 Unmanaged.grid_sampler_3d_ttllb
+
+grid_sampler_3d_backward_tttllba
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+grid_sampler_3d_backward_tttllba = _cast7 Unmanaged.grid_sampler_3d_backward_tttllba
+
+hann_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hann_window_lo = _cast2 Unmanaged.hann_window_lo
+
+hann_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+hann_window_l = _cast1 Unmanaged.hann_window_l
+
+hann_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hann_window_lbo = _cast3 Unmanaged.hann_window_lbo
+
+hann_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+hann_window_lb = _cast2 Unmanaged.hann_window_lb
+
+hamming_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hamming_window_lo = _cast2 Unmanaged.hamming_window_lo
+
+hamming_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+hamming_window_l = _cast1 Unmanaged.hamming_window_l
+
+hamming_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbo = _cast3 Unmanaged.hamming_window_lbo
+
+hamming_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+hamming_window_lb = _cast2 Unmanaged.hamming_window_lb
+
+hamming_window_lbdo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbdo = _cast4 Unmanaged.hamming_window_lbdo
+
+hamming_window_lbd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbd = _cast3 Unmanaged.hamming_window_lbd
+
+hamming_window_lbddo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbddo = _cast5 Unmanaged.hamming_window_lbddo
+
+hamming_window_lbdd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbdd = _cast4 Unmanaged.hamming_window_lbdd
+
+kaiser_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lo = _cast2 Unmanaged.kaiser_window_lo
+
+kaiser_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+kaiser_window_l = _cast1 Unmanaged.kaiser_window_l
+
+kaiser_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lbo = _cast3 Unmanaged.kaiser_window_lbo
+
+kaiser_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lb = _cast2 Unmanaged.kaiser_window_lb
+
+kaiser_window_lbdo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lbdo = _cast4 Unmanaged.kaiser_window_lbdo
+
+kaiser_window_lbd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lbd = _cast3 Unmanaged.kaiser_window_lbd
+
+hinge_embedding_loss_ttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+hinge_embedding_loss_ttdl = _cast4 Unmanaged.hinge_embedding_loss_ttdl
+
+hinge_embedding_loss_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+hinge_embedding_loss_ttd = _cast3 Unmanaged.hinge_embedding_loss_ttd
+
+hinge_embedding_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hinge_embedding_loss_tt = _cast2 Unmanaged.hinge_embedding_loss_tt
+
+group_norm_tlttdb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+group_norm_tlttdb = _cast6 Unmanaged.group_norm_tlttdb
+
+group_norm_tlttd
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+group_norm_tlttd = _cast5 Unmanaged.group_norm_tlttd
+
+group_norm_tltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+group_norm_tltt = _cast4 Unmanaged.group_norm_tltt
+
+group_norm_tlt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+group_norm_tlt = _cast3 Unmanaged.group_norm_tlt
+
+group_norm_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+group_norm_tl = _cast2 Unmanaged.group_norm_tl
+
+native_group_norm_tttlllld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_group_norm_tttlllld = _cast8 Unmanaged.native_group_norm_tttlllld
+
+native_group_norm_backward_tttttlllla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_group_norm_backward_tttttlllla = _cast10 Unmanaged.native_group_norm_backward_tttttlllla
+
+_fft_r2c_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_fft_r2c_tllb = _cast4 Unmanaged._fft_r2c_tllb
+
+_fft_r2c_out_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_fft_r2c_out_ttllb = _cast5 Unmanaged._fft_r2c_out_ttllb
+
+_fft_c2r_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_fft_c2r_tlll = _cast4 Unmanaged._fft_c2r_tlll
+
+_fft_c2r_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_fft_c2r_out_ttlll = _cast5 Unmanaged._fft_c2r_out_ttlll
+
+_fft_c2c_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_fft_c2c_tllb = _cast4 Unmanaged._fft_c2c_tllb
+
+_fft_c2c_out_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_fft_c2c_out_ttllb = _cast5 Unmanaged._fft_c2c_out_ttllb
+
+_validate_compressed_sparse_indices_bttlll
+  :: CBool
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (())
+_validate_compressed_sparse_indices_bttlll = _cast6 Unmanaged._validate_compressed_sparse_indices_bttlll
+
+_cufft_get_plan_cache_size_l
+  :: Int64
+  -> IO (Int64)
+_cufft_get_plan_cache_size_l = _cast1 Unmanaged._cufft_get_plan_cache_size_l
+
+_cufft_get_plan_cache_max_size_l
+  :: Int64
+  -> IO (Int64)
+_cufft_get_plan_cache_max_size_l = _cast1 Unmanaged._cufft_get_plan_cache_max_size_l
+
+_cufft_set_plan_cache_max_size_ll
+  :: Int64
+  -> Int64
+  -> IO (())
+_cufft_set_plan_cache_max_size_ll = _cast2 Unmanaged._cufft_set_plan_cache_max_size_ll
+
+_cufft_clear_plan_cache_l
+  :: Int64
+  -> IO (())
+_cufft_clear_plan_cache_l = _cast1 Unmanaged._cufft_clear_plan_cache_l
+
+index_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> IO (ForeignPtr Tensor)
+index_tl = _cast2 Unmanaged.index_tl
+
+index_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> IO (ForeignPtr Tensor)
+index_out_ttl = _cast3 Unmanaged.index_out_ttl
+
+index_copy_out_ttltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_copy_out_ttltt = _cast5 Unmanaged.index_copy_out_ttltt
+
+index_copy_tltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_copy_tltt = _cast4 Unmanaged.index_copy_tltt
+
+index_copy_tntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_copy_tntt = _cast4 Unmanaged.index_copy_tntt
+
+index_put__tltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+index_put__tltb = _cast4 Unmanaged.index_put__tltb
+
+index_put__tlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_put__tlt = _cast3 Unmanaged.index_put__tlt
+
+index_put_tltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+index_put_tltb = _cast4 Unmanaged.index_put_tltb
+
+index_put_tlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_put_tlt = _cast3 Unmanaged.index_put_tlt
+
+_index_put_impl__tltbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_index_put_impl__tltbb = _cast5 Unmanaged._index_put_impl__tltbb
+
+_index_put_impl__tltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_index_put_impl__tltb = _cast4 Unmanaged._index_put_impl__tltb
+
+_index_put_impl__tlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_index_put_impl__tlt = _cast3 Unmanaged._index_put_impl__tlt
+
+instance_norm_tttttbddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+instance_norm_tttttbddb = _cast9 Unmanaged.instance_norm_tttttbddb
+
+isclose_ttddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isclose_ttddb = _cast5 Unmanaged.isclose_ttddb
+
+isclose_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+isclose_ttdd = _cast4 Unmanaged.isclose_ttdd
+
+isclose_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+isclose_ttd = _cast3 Unmanaged.isclose_ttd
+
+isclose_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isclose_tt = _cast2 Unmanaged.isclose_tt
+
+isin_out_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_out_tttbb = _cast5 Unmanaged.isin_out_tttbb
+
+isin_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_out_tttb = _cast4 Unmanaged.isin_out_tttb
+
+isin_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isin_out_ttt = _cast3 Unmanaged.isin_out_ttt
+
+isin_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_ttbb = _cast4 Unmanaged.isin_ttbb
+
+isin_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_ttb = _cast3 Unmanaged.isin_ttb
+
+isin_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isin_tt = _cast2 Unmanaged.isin_tt
+
+isin_out_ttsbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_out_ttsbb = _cast5 Unmanaged.isin_out_ttsbb
+
+isin_out_ttsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_out_ttsb = _cast4 Unmanaged.isin_out_ttsb
+
+isin_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+isin_out_tts = _cast3 Unmanaged.isin_out_tts
+
+isin_tsbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_tsbb = _cast4 Unmanaged.isin_tsbb
+
+isin_tsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_tsb = _cast3 Unmanaged.isin_tsb
+
+isin_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+isin_ts = _cast2 Unmanaged.isin_ts
+
+isin_out_tstbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_out_tstbb = _cast5 Unmanaged.isin_out_tstbb
+
+isin_out_tstb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_out_tstb = _cast4 Unmanaged.isin_out_tstb
+
+isin_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isin_out_tst = _cast3 Unmanaged.isin_out_tst
+
+isin_stbb
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_stbb = _cast4 Unmanaged.isin_stbb
+
+isin_stb
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+isin_stb = _cast3 Unmanaged.isin_stb
+
+isin_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isin_st = _cast2 Unmanaged.isin_st
+
+isnan_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isnan_t = _cast1 Unmanaged.isnan_t
+
+is_distributed_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+is_distributed_t = _cast1 Unmanaged.is_distributed_t
+
+is_floating_point_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+is_floating_point_t = _cast1 Unmanaged.is_floating_point_t
+
+is_complex_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+is_complex_t = _cast1 Unmanaged.is_complex_t
+
+is_conj_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+is_conj_t = _cast1 Unmanaged.is_conj_t
+
+_is_zerotensor_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+_is_zerotensor_t = _cast1 Unmanaged._is_zerotensor_t
+
+is_neg_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+is_neg_t = _cast1 Unmanaged.is_neg_t
+
+isreal_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+isreal_t = _cast1 Unmanaged.isreal_t
+
+is_nonzero_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+is_nonzero_t = _cast1 Unmanaged.is_nonzero_t
+
+is_same_size_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+is_same_size_tt = _cast2 Unmanaged.is_same_size_tt
+
+is_signed_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+is_signed_t = _cast1 Unmanaged.is_signed_t
+
+is_inference_t
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+is_inference_t = _cast1 Unmanaged.is_inference_t
+
+kl_div_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+kl_div_ttlb = _cast4 Unmanaged.kl_div_ttlb
+
+kl_div_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+kl_div_ttl = _cast3 Unmanaged.kl_div_ttl
+
+kl_div_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+kl_div_tt = _cast2 Unmanaged.kl_div_tt
+
+kron_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+kron_tt = _cast2 Unmanaged.kron_tt
+
+kron_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+kron_out_ttt = _cast3 Unmanaged.kron_out_ttt
+
+kthvalue_tllb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_tllb = _cast4 Unmanaged.kthvalue_tllb
+
+kthvalue_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_tll = _cast3 Unmanaged.kthvalue_tll
+
+kthvalue_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_tl = _cast2 Unmanaged.kthvalue_tl
+
+kthvalue_out_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttllb = _cast6 Unmanaged.kthvalue_out_tttllb
+
+kthvalue_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttll = _cast5 Unmanaged.kthvalue_out_tttll
+
+kthvalue_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttl = _cast4 Unmanaged.kthvalue_out_tttl
+
+kthvalue_tlnb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_tlnb = _cast4 Unmanaged.kthvalue_tlnb
+
+kthvalue_tln
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_tln = _cast3 Unmanaged.kthvalue_tln
+
+kthvalue_out_tttlnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttlnb = _cast6 Unmanaged.kthvalue_out_tttlnb
+
+kthvalue_out_tttln
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttln = _cast5 Unmanaged.kthvalue_out_tttln
+
+layer_norm_tlttdb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+layer_norm_tlttdb = _cast6 Unmanaged.layer_norm_tlttdb
+
+layer_norm_tlttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+layer_norm_tlttd = _cast5 Unmanaged.layer_norm_tlttd
+
+layer_norm_tltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+layer_norm_tltt = _cast4 Unmanaged.layer_norm_tltt
+
+layer_norm_tlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+layer_norm_tlt = _cast3 Unmanaged.layer_norm_tlt
+
+layer_norm_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+layer_norm_tl = _cast2 Unmanaged.layer_norm_tl
+
+native_layer_norm_tlttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_layer_norm_tlttd = _cast5 Unmanaged.native_layer_norm_tlttd
+
+native_layer_norm_backward_ttltttta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_layer_norm_backward_ttltttta = _cast8 Unmanaged.native_layer_norm_backward_ttltttta
+
+nan_to_num_tddd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num_tddd = _cast4 Unmanaged.nan_to_num_tddd
+
+nan_to_num_tdd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num_tdd = _cast3 Unmanaged.nan_to_num_tdd
+
+nan_to_num_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num_td = _cast2 Unmanaged.nan_to_num_td
+
+nan_to_num_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nan_to_num_t = _cast1 Unmanaged.nan_to_num_t
+
+nan_to_num__tddd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num__tddd = _cast4 Unmanaged.nan_to_num__tddd
+
+nan_to_num__tdd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num__tdd = _cast3 Unmanaged.nan_to_num__tdd
+
+nan_to_num__td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num__td = _cast2 Unmanaged.nan_to_num__td
+
+nan_to_num__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nan_to_num__t = _cast1 Unmanaged.nan_to_num__t
+
+nan_to_num_out_ttddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num_out_ttddd = _cast5 Unmanaged.nan_to_num_out_ttddd
+
+nan_to_num_out_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num_out_ttdd = _cast4 Unmanaged.nan_to_num_out_ttdd
+
+nan_to_num_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nan_to_num_out_ttd = _cast3 Unmanaged.nan_to_num_out_ttd
+
+nan_to_num_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nan_to_num_out_tt = _cast2 Unmanaged.nan_to_num_out_tt
+
+linear_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linear_ttt = _cast3 Unmanaged.linear_ttt
+
+linear_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linear_tt = _cast2 Unmanaged.linear_tt
+
+linear_backward_ttta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+linear_backward_ttta = _cast4 Unmanaged.linear_backward_ttta
+
+linear_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linear_out_tttt = _cast4 Unmanaged.linear_out_tttt
+
+linear_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linear_out_ttt = _cast3 Unmanaged.linear_out_ttt
+
+mkldnn_linear_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_linear_ttt = _cast3 Unmanaged.mkldnn_linear_ttt
+
+mkldnn_linear_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_linear_tt = _cast2 Unmanaged.mkldnn_linear_tt
+
+mkldnn_linear_backward_input_ltt
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_linear_backward_input_ltt = _cast3 Unmanaged.mkldnn_linear_backward_input_ltt
+
+mkldnn_linear_backward_weights_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mkldnn_linear_backward_weights_tttb = _cast4 Unmanaged.mkldnn_linear_backward_weights_tttb
+
+mkldnn_linear_backward_ttta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+mkldnn_linear_backward_ttta = _cast4 Unmanaged.mkldnn_linear_backward_ttta
+
+fbgemm_linear_int8_weight_fp32_activation_ttttsst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fbgemm_linear_int8_weight_fp32_activation_ttttsst = _cast7 Unmanaged.fbgemm_linear_int8_weight_fp32_activation_ttttsst
+
+fbgemm_linear_int8_weight_ttttsst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fbgemm_linear_int8_weight_ttttsst = _cast7 Unmanaged.fbgemm_linear_int8_weight_ttttsst
+
+fbgemm_linear_quantize_weight_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,CDouble,Int64)))
+fbgemm_linear_quantize_weight_t = _cast1 Unmanaged.fbgemm_linear_quantize_weight_t
+
+fbgemm_pack_gemm_matrix_fp16_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fbgemm_pack_gemm_matrix_fp16_t = _cast1 Unmanaged.fbgemm_pack_gemm_matrix_fp16_t
+
+fbgemm_linear_fp16_weight_fp32_activation_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fbgemm_linear_fp16_weight_fp32_activation_ttt = _cast3 Unmanaged.fbgemm_linear_fp16_weight_fp32_activation_ttt
+
+fbgemm_linear_fp16_weight_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fbgemm_linear_fp16_weight_ttt = _cast3 Unmanaged.fbgemm_linear_fp16_weight_ttt
+
+fbgemm_pack_quantized_matrix_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fbgemm_pack_quantized_matrix_t = _cast1 Unmanaged.fbgemm_pack_quantized_matrix_t
+
+fbgemm_pack_quantized_matrix_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fbgemm_pack_quantized_matrix_tll = _cast3 Unmanaged.fbgemm_pack_quantized_matrix_tll
+
+ldexp_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ldexp_tt = _cast2 Unmanaged.ldexp_tt
+
+ldexp__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ldexp__tt = _cast2 Unmanaged.ldexp__tt
+
+ldexp_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ldexp_out_ttt = _cast3 Unmanaged.ldexp_out_ttt
+
+linspace_sslo
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+linspace_sslo = _cast4 Unmanaged.linspace_sslo
+
+linspace_ssl
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linspace_ssl = _cast3 Unmanaged.linspace_ssl
+
+linspace_out_tssl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linspace_out_tssl = _cast4 Unmanaged.linspace_out_tssl
+
+log_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log_t = _cast1 Unmanaged.log_t
+
+log__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log__t = _cast1 Unmanaged.log__t
+
+log_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log_out_tt = _cast2 Unmanaged.log_out_tt
+
+log10_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log10_t = _cast1 Unmanaged.log10_t
+
+log10__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log10__t = _cast1 Unmanaged.log10__t
+
+log10_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log10_out_tt = _cast2 Unmanaged.log10_out_tt
+
+log1p_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log1p_t = _cast1 Unmanaged.log1p_t
+
+log1p__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log1p__t = _cast1 Unmanaged.log1p__t
+
+log1p_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log1p_out_tt = _cast2 Unmanaged.log1p_out_tt
+
+log2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log2_t = _cast1 Unmanaged.log2_t
+
+log2__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log2__t = _cast1 Unmanaged.log2__t
+
+log2_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log2_out_tt = _cast2 Unmanaged.log2_out_tt
+
+logaddexp_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logaddexp_out_ttt = _cast3 Unmanaged.logaddexp_out_ttt
+
+logaddexp_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logaddexp_tt = _cast2 Unmanaged.logaddexp_tt
+
+logaddexp2_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logaddexp2_out_ttt = _cast3 Unmanaged.logaddexp2_out_ttt
+
+logaddexp2_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logaddexp2_tt = _cast2 Unmanaged.logaddexp2_tt
+
+xlogy_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+xlogy_tt = _cast2 Unmanaged.xlogy_tt
+
+xlogy_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+xlogy_st = _cast2 Unmanaged.xlogy_st
+
diff --git a/src/Torch/Internal/Managed/Native/Native3.hs b/src/Torch/Internal/Managed/Native/Native3.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native3.hs
@@ -0,0 +1,2288 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native3 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native3 as Unmanaged
+
+
+xlogy_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+xlogy_ts = _cast2 Unmanaged.xlogy_ts
+
+xlogy__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+xlogy__tt = _cast2 Unmanaged.xlogy__tt
+
+xlogy__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+xlogy__ts = _cast2 Unmanaged.xlogy__ts
+
+xlogy_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+xlogy_out_ttt = _cast3 Unmanaged.xlogy_out_ttt
+
+xlogy_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+xlogy_out_tst = _cast3 Unmanaged.xlogy_out_tst
+
+xlogy_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+xlogy_out_tts = _cast3 Unmanaged.xlogy_out_tts
+
+logspace_ssldo
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+logspace_ssldo = _cast5 Unmanaged.logspace_ssldo
+
+logspace_ssld
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+logspace_ssld = _cast4 Unmanaged.logspace_ssld
+
+logspace_ssl
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+logspace_ssl = _cast3 Unmanaged.logspace_ssl
+
+logspace_out_tssld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+logspace_out_tssld = _cast5 Unmanaged.logspace_out_tssld
+
+logspace_out_tssl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+logspace_out_tssl = _cast4 Unmanaged.logspace_out_tssl
+
+log_softmax_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+log_softmax_tls = _cast3 Unmanaged.log_softmax_tls
+
+log_softmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+log_softmax_tl = _cast2 Unmanaged.log_softmax_tl
+
+log_softmax_out_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+log_softmax_out_ttls = _cast4 Unmanaged.log_softmax_out_ttls
+
+log_softmax_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+log_softmax_out_ttl = _cast3 Unmanaged.log_softmax_out_ttl
+
+log_softmax_tns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+log_softmax_tns = _cast3 Unmanaged.log_softmax_tns
+
+log_softmax_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+log_softmax_tn = _cast2 Unmanaged.log_softmax_tn
+
+_log_softmax_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_log_softmax_tlb = _cast3 Unmanaged._log_softmax_tlb
+
+_log_softmax_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_log_softmax_out_ttlb = _cast4 Unmanaged._log_softmax_out_ttlb
+
+_log_softmax_backward_data_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_log_softmax_backward_data_ttls = _cast4 Unmanaged._log_softmax_backward_data_ttls
+
+_log_softmax_backward_data_out_tttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_log_softmax_backward_data_out_tttls = _cast5 Unmanaged._log_softmax_backward_data_out_tttls
+
+_logcumsumexp_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_logcumsumexp_tl = _cast2 Unmanaged._logcumsumexp_tl
+
+_logcumsumexp_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_logcumsumexp_out_ttl = _cast3 Unmanaged._logcumsumexp_out_ttl
+
+logcumsumexp_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+logcumsumexp_tl = _cast2 Unmanaged.logcumsumexp_tl
+
+logcumsumexp_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+logcumsumexp_out_ttl = _cast3 Unmanaged.logcumsumexp_out_ttl
+
+logcumsumexp_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+logcumsumexp_tn = _cast2 Unmanaged.logcumsumexp_tn
+
+logcumsumexp_out_ttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+logcumsumexp_out_ttn = _cast3 Unmanaged.logcumsumexp_out_ttn
+
+logsumexp_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+logsumexp_tlb = _cast3 Unmanaged.logsumexp_tlb
+
+logsumexp_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+logsumexp_tl = _cast2 Unmanaged.logsumexp_tl
+
+logsumexp_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+logsumexp_out_ttlb = _cast4 Unmanaged.logsumexp_out_ttlb
+
+logsumexp_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+logsumexp_out_ttl = _cast3 Unmanaged.logsumexp_out_ttl
+
+logsumexp_tNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+logsumexp_tNb = _cast3 Unmanaged.logsumexp_tNb
+
+logsumexp_tN
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+logsumexp_tN = _cast2 Unmanaged.logsumexp_tN
+
+logsumexp_out_ttNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+logsumexp_out_ttNb = _cast4 Unmanaged.logsumexp_out_ttNb
+
+logsumexp_out_ttN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+logsumexp_out_ttN = _cast3 Unmanaged.logsumexp_out_ttN
+
+margin_ranking_loss_tttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+margin_ranking_loss_tttdl = _cast5 Unmanaged.margin_ranking_loss_tttdl
+
+margin_ranking_loss_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+margin_ranking_loss_tttd = _cast4 Unmanaged.margin_ranking_loss_tttd
+
+margin_ranking_loss_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+margin_ranking_loss_ttt = _cast3 Unmanaged.margin_ranking_loss_ttt
+
+matmul_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+matmul_tt = _cast2 Unmanaged.matmul_tt
+
+matmul_backward_ttta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+matmul_backward_ttta = _cast4 Unmanaged.matmul_backward_ttta
+
+matmul_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+matmul_out_ttt = _cast3 Unmanaged.matmul_out_ttt
+
+matrix_power_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+matrix_power_tl = _cast2 Unmanaged.matrix_power_tl
+
+matrix_power_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+matrix_power_out_ttl = _cast3 Unmanaged.matrix_power_out_ttl
+
+matrix_exp_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+matrix_exp_t = _cast1 Unmanaged.matrix_exp_t
+
+matrix_exp_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+matrix_exp_backward_tt = _cast2 Unmanaged.matrix_exp_backward_tt
+
+_aminmax_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_aminmax_t = _cast1 Unmanaged._aminmax_t
+
+_aminmax_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_aminmax_tlb = _cast3 Unmanaged._aminmax_tlb
+
+_aminmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_aminmax_tl = _cast2 Unmanaged._aminmax_tl
+
+aminmax_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+aminmax_tlb = _cast3 Unmanaged.aminmax_tlb
+
+aminmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+aminmax_tl = _cast2 Unmanaged.aminmax_tl
+
+aminmax_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+aminmax_t = _cast1 Unmanaged.aminmax_t
+
+aminmax_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+aminmax_out_tttlb = _cast5 Unmanaged.aminmax_out_tttlb
+
+aminmax_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+aminmax_out_tttl = _cast4 Unmanaged.aminmax_out_tttl
+
+aminmax_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+aminmax_out_ttt = _cast3 Unmanaged.aminmax_out_ttt
+
+_compute_linear_combination_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_compute_linear_combination_tt = _cast2 Unmanaged._compute_linear_combination_tt
+
+_compute_linear_combination_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_compute_linear_combination_out_ttt = _cast3 Unmanaged._compute_linear_combination_out_ttt
+
+max_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_tlb = _cast3 Unmanaged.max_tlb
+
+max_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_tl = _cast2 Unmanaged.max_tl
+
+max_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_out_tttlb = _cast5 Unmanaged.max_out_tttlb
+
+max_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_out_tttl = _cast4 Unmanaged.max_out_tttl
+
+max_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_tnb = _cast3 Unmanaged.max_tnb
+
+max_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_tn = _cast2 Unmanaged.max_tn
+
+max_out_tttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_out_tttnb = _cast5 Unmanaged.max_out_tttnb
+
+max_out_tttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_out_tttn = _cast4 Unmanaged.max_out_tttn
+
+value_selecting_reduction_backward_tltlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+value_selecting_reduction_backward_tltlb = _cast5 Unmanaged.value_selecting_reduction_backward_tltlb
+
+amax_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+amax_tlb = _cast3 Unmanaged.amax_tlb
+
+amax_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+amax_tl = _cast2 Unmanaged.amax_tl
+
+amax_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+amax_t = _cast1 Unmanaged.amax_t
+
+amax_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+amax_out_ttlb = _cast4 Unmanaged.amax_out_ttlb
+
+amax_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+amax_out_ttl = _cast3 Unmanaged.amax_out_ttl
+
+amax_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+amax_out_tt = _cast2 Unmanaged.amax_out_tt
+
+max_pool1d_with_indices_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tllllb = _cast6 Unmanaged.max_pool1d_with_indices_tllllb
+
+max_pool1d_with_indices_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tllll = _cast5 Unmanaged.max_pool1d_with_indices_tllll
+
+max_pool1d_with_indices_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tlll = _cast4 Unmanaged.max_pool1d_with_indices_tlll
+
+max_pool1d_with_indices_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tll = _cast3 Unmanaged.max_pool1d_with_indices_tll
+
+max_pool1d_with_indices_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tl = _cast2 Unmanaged.max_pool1d_with_indices_tl
+
+max_pool1d_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+max_pool1d_tllllb = _cast6 Unmanaged.max_pool1d_tllllb
+
+max_pool1d_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool1d_tllll = _cast5 Unmanaged.max_pool1d_tllll
+
+max_pool1d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool1d_tlll = _cast4 Unmanaged.max_pool1d_tlll
+
+max_pool1d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool1d_tll = _cast3 Unmanaged.max_pool1d_tll
+
+max_pool1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool1d_tl = _cast2 Unmanaged.max_pool1d_tl
+
+max_pool2d_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+max_pool2d_tllllb = _cast6 Unmanaged.max_pool2d_tllllb
+
+max_pool2d_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_tllll = _cast5 Unmanaged.max_pool2d_tllll
+
+max_pool2d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_tlll = _cast4 Unmanaged.max_pool2d_tlll
+
+max_pool2d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_tll = _cast3 Unmanaged.max_pool2d_tll
+
+max_pool2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_tl = _cast2 Unmanaged.max_pool2d_tl
+
+max_pool2d_backward_ttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_ttllllb = _cast7 Unmanaged.max_pool2d_backward_ttllllb
+
+max_pool2d_backward_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_ttllll = _cast6 Unmanaged.max_pool2d_backward_ttllll
+
+max_pool2d_backward_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_ttlll = _cast5 Unmanaged.max_pool2d_backward_ttlll
+
+max_pool2d_backward_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_ttll = _cast4 Unmanaged.max_pool2d_backward_ttll
+
+max_pool2d_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool2d_backward_ttl = _cast3 Unmanaged.max_pool2d_backward_ttl
+
+mkldnn_max_pool2d_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_tllllb = _cast6 Unmanaged.mkldnn_max_pool2d_tllllb
+
+mkldnn_max_pool2d_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_tllll = _cast5 Unmanaged.mkldnn_max_pool2d_tllll
+
+mkldnn_max_pool2d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_tlll = _cast4 Unmanaged.mkldnn_max_pool2d_tlll
+
+mkldnn_max_pool2d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_tll = _cast3 Unmanaged.mkldnn_max_pool2d_tll
+
+mkldnn_max_pool2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_tl = _cast2 Unmanaged.mkldnn_max_pool2d_tl
+
+mkldnn_max_pool2d_backward_tttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_tttllllb = _cast8 Unmanaged.mkldnn_max_pool2d_backward_tttllllb
+
+mkldnn_max_pool2d_backward_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_tttllll = _cast7 Unmanaged.mkldnn_max_pool2d_backward_tttllll
+
+mkldnn_max_pool2d_backward_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_tttlll = _cast6 Unmanaged.mkldnn_max_pool2d_backward_tttlll
+
+mkldnn_max_pool2d_backward_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_tttll = _cast5 Unmanaged.mkldnn_max_pool2d_backward_tttll
+
+mkldnn_max_pool2d_backward_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool2d_backward_tttl = _cast4 Unmanaged.mkldnn_max_pool2d_backward_tttl
+
+mkldnn_max_pool3d_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_tllllb = _cast6 Unmanaged.mkldnn_max_pool3d_tllllb
+
+mkldnn_max_pool3d_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_tllll = _cast5 Unmanaged.mkldnn_max_pool3d_tllll
+
+mkldnn_max_pool3d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_tlll = _cast4 Unmanaged.mkldnn_max_pool3d_tlll
+
+mkldnn_max_pool3d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_tll = _cast3 Unmanaged.mkldnn_max_pool3d_tll
+
+mkldnn_max_pool3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_tl = _cast2 Unmanaged.mkldnn_max_pool3d_tl
+
+mkldnn_max_pool3d_backward_tttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_tttllllb = _cast8 Unmanaged.mkldnn_max_pool3d_backward_tttllllb
+
+mkldnn_max_pool3d_backward_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_tttllll = _cast7 Unmanaged.mkldnn_max_pool3d_backward_tttllll
+
+mkldnn_max_pool3d_backward_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_tttlll = _cast6 Unmanaged.mkldnn_max_pool3d_backward_tttlll
+
+mkldnn_max_pool3d_backward_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_tttll = _cast5 Unmanaged.mkldnn_max_pool3d_backward_tttll
+
+mkldnn_max_pool3d_backward_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_max_pool3d_backward_tttl = _cast4 Unmanaged.mkldnn_max_pool3d_backward_tttl
+
+quantized_max_pool1d_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_tllllb = _cast6 Unmanaged.quantized_max_pool1d_tllllb
+
+quantized_max_pool1d_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_tllll = _cast5 Unmanaged.quantized_max_pool1d_tllll
+
+quantized_max_pool1d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_tlll = _cast4 Unmanaged.quantized_max_pool1d_tlll
+
+quantized_max_pool1d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_tll = _cast3 Unmanaged.quantized_max_pool1d_tll
+
+quantized_max_pool1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool1d_tl = _cast2 Unmanaged.quantized_max_pool1d_tl
+
+quantized_max_pool2d_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_tllllb = _cast6 Unmanaged.quantized_max_pool2d_tllllb
+
+quantized_max_pool2d_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_tllll = _cast5 Unmanaged.quantized_max_pool2d_tllll
+
+quantized_max_pool2d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_tlll = _cast4 Unmanaged.quantized_max_pool2d_tlll
+
+quantized_max_pool2d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_tll = _cast3 Unmanaged.quantized_max_pool2d_tll
+
+quantized_max_pool2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+quantized_max_pool2d_tl = _cast2 Unmanaged.quantized_max_pool2d_tl
+
+max_pool3d_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+max_pool3d_tllllb = _cast6 Unmanaged.max_pool3d_tllllb
+
+max_pool3d_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool3d_tllll = _cast5 Unmanaged.max_pool3d_tllll
+
+max_pool3d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool3d_tlll = _cast4 Unmanaged.max_pool3d_tlll
+
+max_pool3d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool3d_tll = _cast3 Unmanaged.max_pool3d_tll
+
+max_pool3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_pool3d_tl = _cast2 Unmanaged.max_pool3d_tl
+
+mean_ts
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+mean_ts = _cast2 Unmanaged.mean_ts
+
+mean_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mean_t = _cast1 Unmanaged.mean_t
+
+mean_tlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+mean_tlbs = _cast4 Unmanaged.mean_tlbs
+
+mean_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mean_tlb = _cast3 Unmanaged.mean_tlb
+
+mean_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mean_tl = _cast2 Unmanaged.mean_tl
+
+mean_out_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+mean_out_ttlbs = _cast5 Unmanaged.mean_out_ttlbs
+
+mean_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mean_out_ttlb = _cast4 Unmanaged.mean_out_ttlb
+
+mean_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mean_out_ttl = _cast3 Unmanaged.mean_out_ttl
+
+mean_tNbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+mean_tNbs = _cast4 Unmanaged.mean_tNbs
+
+mean_tNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mean_tNb = _cast3 Unmanaged.mean_tNb
+
+mean_tN
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+mean_tN = _cast2 Unmanaged.mean_tN
+
+mean_out_ttNbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+mean_out_ttNbs = _cast5 Unmanaged.mean_out_ttNbs
+
+mean_out_ttNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+mean_out_ttNb = _cast4 Unmanaged.mean_out_ttNb
+
+mean_out_ttN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+mean_out_ttN = _cast3 Unmanaged.mean_out_ttN
+
+nanmean_tlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+nanmean_tlbs = _cast4 Unmanaged.nanmean_tlbs
+
+nanmean_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nanmean_tlb = _cast3 Unmanaged.nanmean_tlb
+
+nanmean_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+nanmean_tl = _cast2 Unmanaged.nanmean_tl
+
+nanmean_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nanmean_t = _cast1 Unmanaged.nanmean_t
+
+nanmean_out_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+nanmean_out_ttlbs = _cast5 Unmanaged.nanmean_out_ttlbs
+
+nanmean_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nanmean_out_ttlb = _cast4 Unmanaged.nanmean_out_ttlb
+
+nanmean_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+nanmean_out_ttl = _cast3 Unmanaged.nanmean_out_ttl
+
+nanmean_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nanmean_out_tt = _cast2 Unmanaged.nanmean_out_tt
+
+median_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+median_t = _cast1 Unmanaged.median_t
+
+median_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+median_tlb = _cast3 Unmanaged.median_tlb
+
+median_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+median_tl = _cast2 Unmanaged.median_tl
+
+median_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+median_out_tttlb = _cast5 Unmanaged.median_out_tttlb
+
+median_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+median_out_tttl = _cast4 Unmanaged.median_out_tttl
+
+median_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+median_tnb = _cast3 Unmanaged.median_tnb
+
+median_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+median_tn = _cast2 Unmanaged.median_tn
+
+median_out_tttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+median_out_tttnb = _cast5 Unmanaged.median_out_tttnb
+
+median_out_tttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+median_out_tttn = _cast4 Unmanaged.median_out_tttn
+
+nanmedian_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nanmedian_t = _cast1 Unmanaged.nanmedian_t
+
+nanmedian_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nanmedian_tlb = _cast3 Unmanaged.nanmedian_tlb
+
+nanmedian_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nanmedian_tl = _cast2 Unmanaged.nanmedian_tl
+
+nanmedian_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nanmedian_out_tttlb = _cast5 Unmanaged.nanmedian_out_tttlb
+
+nanmedian_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nanmedian_out_tttl = _cast4 Unmanaged.nanmedian_out_tttl
+
+nanmedian_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nanmedian_tnb = _cast3 Unmanaged.nanmedian_tnb
+
+nanmedian_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nanmedian_tn = _cast2 Unmanaged.nanmedian_tn
+
+nanmedian_out_tttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nanmedian_out_tttnb = _cast5 Unmanaged.nanmedian_out_tttnb
+
+nanmedian_out_tttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nanmedian_out_tttn = _cast4 Unmanaged.nanmedian_out_tttn
+
+min_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+min_tlb = _cast3 Unmanaged.min_tlb
+
+min_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+min_tl = _cast2 Unmanaged.min_tl
+
+min_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+min_out_tttlb = _cast5 Unmanaged.min_out_tttlb
+
+min_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+min_out_tttl = _cast4 Unmanaged.min_out_tttl
+
+min_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+min_tnb = _cast3 Unmanaged.min_tnb
+
+min_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+min_tn = _cast2 Unmanaged.min_tn
+
+min_out_tttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+min_out_tttnb = _cast5 Unmanaged.min_out_tttnb
+
+min_out_tttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+min_out_tttn = _cast4 Unmanaged.min_out_tttn
+
+amin_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+amin_tlb = _cast3 Unmanaged.amin_tlb
+
+amin_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+amin_tl = _cast2 Unmanaged.amin_tl
+
+amin_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+amin_t = _cast1 Unmanaged.amin_t
+
+amin_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+amin_out_ttlb = _cast4 Unmanaged.amin_out_ttlb
+
+amin_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+amin_out_ttl = _cast3 Unmanaged.amin_out_ttl
+
+amin_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+amin_out_tt = _cast2 Unmanaged.amin_out_tt
+
+_mps_convolution_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_mps_convolution_tttllll = _cast7 Unmanaged._mps_convolution_tttllll
+
+mps_convolution_backward_tttlllla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+mps_convolution_backward_tttlllla = _cast8 Unmanaged.mps_convolution_backward_tttlllla
+
+mkldnn_convolution_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mkldnn_convolution_tttllll = _cast7 Unmanaged.mkldnn_convolution_tttllll
+
+mkldnn_rnn_layer_tttttttbllllbbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+mkldnn_rnn_layer_tttttttbllllbbbb = _cast16 Unmanaged.mkldnn_rnn_layer_tttttttbllllbbbb
+
+mkldnn_rnn_layer_backward_tttttttttttttblllbbblbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+mkldnn_rnn_layer_backward_tttttttttttttblllbbblbt = _cast23 Unmanaged.mkldnn_rnn_layer_backward_tttttttttttttblllbbblbt
+
+miopen_batch_norm_tttttbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+miopen_batch_norm_tttttbdd = _cast8 Unmanaged.miopen_batch_norm_tttttbdd
+
+miopen_batch_norm_backward_tttttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+miopen_batch_norm_backward_tttttttd = _cast8 Unmanaged.miopen_batch_norm_backward_tttttttd
+
+miopen_convolution_tttllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+miopen_convolution_tttllllbb = _cast9 Unmanaged.miopen_convolution_tttllllbb
+
+miopen_convolution_transpose_tttlllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+miopen_convolution_transpose_tttlllllbb = _cast10 Unmanaged.miopen_convolution_transpose_tttlllllbb
+
+miopen_depthwise_convolution_tttllllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+miopen_depthwise_convolution_tttllllbb = _cast9 Unmanaged.miopen_depthwise_convolution_tttllllbb
+
+miopen_convolution_relu_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+miopen_convolution_relu_tttllll = _cast7 Unmanaged.miopen_convolution_relu_tttllll
+
+miopen_convolution_add_relu_tttstllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+miopen_convolution_add_relu_tttstllll = _cast9 Unmanaged.miopen_convolution_add_relu_tttstllll
+
+miopen_rnn_tllttlllbdbblt
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+miopen_rnn_tllttlllbdbblt = _cast14 Unmanaged.miopen_rnn_tllttlllbdbblt
+
+miopen_rnn_backward_tlltttttttlllbdbbltta
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,4))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList)))
+miopen_rnn_backward_tlltttttttlllbdbbltta = _cast21 Unmanaged.miopen_rnn_backward_tlltttttttlllbdbbltta
+
+mm_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mm_tt = _cast2 Unmanaged.mm_tt
+
+mm_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mm_out_ttt = _cast3 Unmanaged.mm_out_ttt
+
+_sparse_mm_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_mm_tt = _cast2 Unmanaged._sparse_mm_tt
+
+_sparse_mm_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+_sparse_mm_tts = _cast3 Unmanaged._sparse_mm_tts
+
+_sparse_sparse_matmul_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_sparse_matmul_tt = _cast2 Unmanaged._sparse_sparse_matmul_tt
+
+mode_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_tlb = _cast3 Unmanaged.mode_tlb
+
+mode_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_tl = _cast2 Unmanaged.mode_tl
+
+mode_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_t = _cast1 Unmanaged.mode_t
+
+mode_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_out_tttlb = _cast5 Unmanaged.mode_out_tttlb
+
+mode_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_out_tttl = _cast4 Unmanaged.mode_out_tttl
+
+mode_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_out_ttt = _cast3 Unmanaged.mode_out_ttt
+
+mode_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_tnb = _cast3 Unmanaged.mode_tnb
+
+mode_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_tn = _cast2 Unmanaged.mode_tn
+
+mode_out_tttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_out_tttnb = _cast5 Unmanaged.mode_out_tttnb
+
+mode_out_tttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+mode_out_tttn = _cast4 Unmanaged.mode_out_tttn
+
+mul_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mul_tt = _cast2 Unmanaged.mul_tt
+
+mul_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mul_out_ttt = _cast3 Unmanaged.mul_out_ttt
+
+mul_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+mul_ts = _cast2 Unmanaged.mul_ts
+
+multiply_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multiply_tt = _cast2 Unmanaged.multiply_tt
+
+multiply_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multiply_out_ttt = _cast3 Unmanaged.multiply_out_ttt
+
+multiply_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+multiply_ts = _cast2 Unmanaged.multiply_ts
+
+mv_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mv_tt = _cast2 Unmanaged.mv_tt
+
+mv_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mv_out_ttt = _cast3 Unmanaged.mv_out_ttt
+
+mvlgamma_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mvlgamma_out_ttl = _cast3 Unmanaged.mvlgamma_out_ttl
+
+mvlgamma_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mvlgamma_tl = _cast2 Unmanaged.mvlgamma_tl
+
+narrow_copy_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+narrow_copy_tlll = _cast4 Unmanaged.narrow_copy_tlll
+
+narrow_copy_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+narrow_copy_out_ttlll = _cast5 Unmanaged.narrow_copy_out_ttlll
+
+narrow_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> 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
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> 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
+
+_native_batch_norm_legit_tttttbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_native_batch_norm_legit_tttttbdd = _cast8 Unmanaged._native_batch_norm_legit_tttttbdd
+
+_native_batch_norm_legit_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_legit_out_ttttttttbdd = _cast11 Unmanaged._native_batch_norm_legit_out_ttttttttbdd
+
+_native_batch_norm_legit_tttbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_native_batch_norm_legit_tttbdd = _cast6 Unmanaged._native_batch_norm_legit_tttbdd
+
+_native_batch_norm_legit_out_ttttttbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_native_batch_norm_legit_out_ttttttbdd = _cast9 Unmanaged._native_batch_norm_legit_out_ttttttbdd
+
+batch_norm_stats_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+batch_norm_stats_td = _cast2 Unmanaged.batch_norm_stats_td
+
+batch_norm_elemt_tttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+batch_norm_elemt_tttttd = _cast6 Unmanaged.batch_norm_elemt_tttttd
+
+batch_norm_elemt_out_ttttttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+batch_norm_elemt_out_ttttttd = _cast7 Unmanaged.batch_norm_elemt_out_ttttttd
+
+batch_norm_gather_stats_tttttddl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+batch_norm_gather_stats_tttttddl = _cast8 Unmanaged.batch_norm_gather_stats_tttttddl
+
+batch_norm_gather_stats_with_counts_tttttddt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+batch_norm_gather_stats_with_counts_tttttddt = _cast8 Unmanaged.batch_norm_gather_stats_with_counts_tttttddt
+
+native_batch_norm_backward_tttttttbda
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CDouble
+  -> ForeignPtr (StdArray '(CBool,3))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+native_batch_norm_backward_tttttttbda = _cast10 Unmanaged.native_batch_norm_backward_tttttttbda
+
+batch_norm_backward_reduce_tttttbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+batch_norm_backward_reduce_tttttbbb = _cast8 Unmanaged.batch_norm_backward_reduce_tttttbbb
+
+batch_norm_backward_elemt_tttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+batch_norm_backward_elemt_tttttttt = _cast8 Unmanaged.batch_norm_backward_elemt_tttttttt
+
+batch_norm_update_stats_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+batch_norm_update_stats_tttd = _cast4 Unmanaged.batch_norm_update_stats_tttd
+
+is_vulkan_available
+  :: IO (CBool)
+is_vulkan_available = _cast0 Unmanaged.is_vulkan_available
+
+_nnpack_available
+  :: IO (CBool)
+_nnpack_available = _cast0 Unmanaged._nnpack_available
+
+_nnpack_spatial_convolution_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_nnpack_spatial_convolution_tttll = _cast5 Unmanaged._nnpack_spatial_convolution_tttll
+
+_nnpack_spatial_convolution_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_nnpack_spatial_convolution_tttl = _cast4 Unmanaged._nnpack_spatial_convolution_tttl
+
+ones_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+ones_lNo = _cast3 Unmanaged.ones_lNo
+
+ones_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+ones_lN = _cast2 Unmanaged.ones_lN
+
+ones_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+ones_lo = _cast2 Unmanaged.ones_lo
+
+ones_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+ones_l = _cast1 Unmanaged.ones_l
+
+ones_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+ones_out_tl = _cast2 Unmanaged.ones_out_tl
+
+ones_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+ones_like_toM = _cast3 Unmanaged.ones_like_toM
+
+ones_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+pairwise_distance_ttddb = _cast5 Unmanaged.pairwise_distance_ttddb
+
+pairwise_distance_ttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+pairwise_distance_ttdd = _cast4 Unmanaged.pairwise_distance_ttdd
+
+pairwise_distance_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+pairwise_distance_ttd = _cast3 Unmanaged.pairwise_distance_ttd
+
+pairwise_distance_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+pairwise_distance_tt = _cast2 Unmanaged.pairwise_distance_tt
+
+cdist_ttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cdist_ttdl = _cast4 Unmanaged.cdist_ttdl
+
+cdist_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+cdist_ttd = _cast3 Unmanaged.cdist_ttd
+
+cdist_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cdist_tt = _cast2 Unmanaged.cdist_tt
+
+_euclidean_dist_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_euclidean_dist_tt = _cast2 Unmanaged._euclidean_dist_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
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_cdist_backward_tttdt = _cast5 Unmanaged._cdist_backward_tttdt
+
+pdist_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+pdist_td = _cast2 Unmanaged.pdist_td
+
+pdist_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+pdist_t = _cast1 Unmanaged.pdist_t
+
+_pdist_forward_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_pdist_forward_td = _cast2 Unmanaged._pdist_forward_td
+
+_pdist_forward_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_pdist_forward_t = _cast1 Unmanaged._pdist_forward_t
+
+_pdist_backward_ttdt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_pdist_backward_ttdt = _cast4 Unmanaged._pdist_backward_ttdt
+
+cosine_similarity_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+cosine_similarity_ttld = _cast4 Unmanaged.cosine_similarity_ttld
+
+cosine_similarity_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cosine_similarity_ttl = _cast3 Unmanaged.cosine_similarity_ttl
+
+cosine_similarity_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cosine_similarity_tt = _cast2 Unmanaged.cosine_similarity_tt
+
+permute_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+permute_tl = _cast2 Unmanaged.permute_tl
+
+movedim_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+movedim_tll = _cast3 Unmanaged.movedim_tll
+
+moveaxis_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+moveaxis_tll = _cast3 Unmanaged.moveaxis_tll
+
+adjoint_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+adjoint_t = _cast1 Unmanaged.adjoint_t
+
+pixel_shuffle_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+pixel_shuffle_tl = _cast2 Unmanaged.pixel_shuffle_tl
+
+pixel_unshuffle_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+pixel_unshuffle_tl = _cast2 Unmanaged.pixel_unshuffle_tl
+
+channel_shuffle_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+channel_shuffle_tl = _cast2 Unmanaged.channel_shuffle_tl
+
+native_channel_shuffle_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+native_channel_shuffle_tl = _cast2 Unmanaged.native_channel_shuffle_tl
+
+_pin_memory_tD
+  :: ForeignPtr Tensor
+  -> DeviceType
+  -> IO (ForeignPtr Tensor)
+_pin_memory_tD = _cast2 Unmanaged._pin_memory_tD
+
+_pin_memory_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_pin_memory_t = _cast1 Unmanaged._pin_memory_t
+
+pinverse_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+pinverse_td = _cast2 Unmanaged.pinverse_td
+
+pinverse_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+pinverse_t = _cast1 Unmanaged.pinverse_t
+
+poisson_nll_loss_ttbbdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+poisson_nll_loss_ttbbdl = _cast6 Unmanaged.poisson_nll_loss_ttbbdl
+
+rad2deg_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rad2deg_t = _cast1 Unmanaged.rad2deg_t
+
+rad2deg__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rad2deg__t = _cast1 Unmanaged.rad2deg__t
+
+rad2deg_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rad2deg_out_tt = _cast2 Unmanaged.rad2deg_out_tt
+
+deg2rad_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+deg2rad_t = _cast1 Unmanaged.deg2rad_t
+
+deg2rad__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+deg2rad__t = _cast1 Unmanaged.deg2rad__t
+
+deg2rad_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+deg2rad_out_tt = _cast2 Unmanaged.deg2rad_out_tt
+
+scalar_tensor_so
+  :: ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+scalar_tensor_so = _cast2 Unmanaged.scalar_tensor_so
+
+scalar_tensor_s
+  :: ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+scalar_tensor_s = _cast1 Unmanaged.scalar_tensor_s
+
+rand_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+rand_lNo = _cast3 Unmanaged.rand_lNo
+
diff --git a/src/Torch/Internal/Managed/Native/Native4.hs b/src/Torch/Internal/Managed/Native/Native4.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native4.hs
@@ -0,0 +1,1889 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native4 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native4 as Unmanaged
+
+
+rand_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+rand_lN = _cast2 Unmanaged.rand_lN
+
+rand_lGNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+rand_lGNo = _cast4 Unmanaged.rand_lGNo
+
+rand_lGN
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+rand_lGN = _cast3 Unmanaged.rand_lGN
+
+rand_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+rand_lo = _cast2 Unmanaged.rand_lo
+
+rand_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+rand_l = _cast1 Unmanaged.rand_l
+
+rand_lGo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+rand_lGo = _cast3 Unmanaged.rand_lGo
+
+rand_lG
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+rand_lG = _cast2 Unmanaged.rand_lG
+
+rand_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+rand_out_tl = _cast2 Unmanaged.rand_out_tl
+
+rand_out_tlG
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+rand_out_tlG = _cast3 Unmanaged.rand_out_tlG
+
+rand_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+rand_like_toM = _cast3 Unmanaged.rand_like_toM
+
+rand_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randint_llo = _cast3 Unmanaged.randint_llo
+
+randint_ll
+  :: Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randint_ll = _cast2 Unmanaged.randint_ll
+
+randint_llGo
+  :: Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randint_llGo = _cast4 Unmanaged.randint_llGo
+
+randint_llG
+  :: Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randint_llG = _cast3 Unmanaged.randint_llG
+
+randint_lllo
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randint_lllo = _cast4 Unmanaged.randint_lllo
+
+randint_lll
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randint_lll = _cast3 Unmanaged.randint_lll
+
+randint_lllGo
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randint_lllGo = _cast5 Unmanaged.randint_lllGo
+
+randint_lllG
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randint_lllG = _cast4 Unmanaged.randint_lllG
+
+randint_out_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randint_out_tll = _cast3 Unmanaged.randint_out_tll
+
+randint_out_tllG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randint_out_tllG = _cast4 Unmanaged.randint_out_tllG
+
+randint_out_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randint_out_tlll = _cast4 Unmanaged.randint_out_tlll
+
+randint_out_tlllG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randint_out_tlllG = _cast5 Unmanaged.randint_out_tlllG
+
+randint_like_tloM
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randint_like_tloM = _cast4 Unmanaged.randint_like_tloM
+
+randint_like_tlo
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randint_like_tlloM = _cast5 Unmanaged.randint_like_tlloM
+
+randint_like_tllo
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> IO (ForeignPtr Tensor)
+randn_lo = _cast2 Unmanaged.randn_lo
+
+randn_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randn_l = _cast1 Unmanaged.randn_l
+
+randn_lGo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randn_lGo = _cast3 Unmanaged.randn_lGo
+
+randn_lG
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randn_lG = _cast2 Unmanaged.randn_lG
+
+randn_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randn_lNo = _cast3 Unmanaged.randn_lNo
+
+randn_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+randn_lN = _cast2 Unmanaged.randn_lN
+
+randn_lGNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randn_lGNo = _cast4 Unmanaged.randn_lGNo
+
+randn_lGN
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+randn_lGN = _cast3 Unmanaged.randn_lGN
+
+randn_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randn_out_tl = _cast2 Unmanaged.randn_out_tl
+
+randn_out_tlG
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randn_out_tlG = _cast3 Unmanaged.randn_out_tlG
+
+randn_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randn_like_toM = _cast3 Unmanaged.randn_like_toM
+
+randn_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> IO (ForeignPtr Tensor)
+randperm_lo = _cast2 Unmanaged.randperm_lo
+
+randperm_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+randperm_l = _cast1 Unmanaged.randperm_l
+
+randperm_lGo
+  :: Int64
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randperm_lGo = _cast3 Unmanaged.randperm_lGo
+
+randperm_lG
+  :: Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randperm_lG = _cast2 Unmanaged.randperm_lG
+
+randperm_out_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+randperm_out_tl = _cast2 Unmanaged.randperm_out_tl
+
+randperm_out_tlG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randperm_out_tlG = _cast3 Unmanaged.randperm_out_tlG
+
+range_ssso
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+range_ssso = _cast4 Unmanaged.range_ssso
+
+range_sss
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+range_sss = _cast3 Unmanaged.range_sss
+
+range_out_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+range_out_tss = _cast3 Unmanaged.range_out_tss
+
+range_out_tsss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+range_out_tsss = _cast4 Unmanaged.range_out_tsss
+
+ravel_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ravel_t = _cast1 Unmanaged.ravel_t
+
+reciprocal_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+reciprocal_t = _cast1 Unmanaged.reciprocal_t
+
+reciprocal__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+reciprocal__t = _cast1 Unmanaged.reciprocal__t
+
+reciprocal_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+reciprocal_out_tt = _cast2 Unmanaged.reciprocal_out_tt
+
+neg_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+neg_t = _cast1 Unmanaged.neg_t
+
+neg__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+neg__t = _cast1 Unmanaged.neg__t
+
+neg_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+neg_out_tt = _cast2 Unmanaged.neg_out_tt
+
+negative_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+negative_t = _cast1 Unmanaged.negative_t
+
+negative__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+negative__t = _cast1 Unmanaged.negative__t
+
+negative_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+negative_out_tt = _cast2 Unmanaged.negative_out_tt
+
+repeat_interleave_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_tl = _cast2 Unmanaged.repeat_interleave_tl
+
+repeat_interleave_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_t = _cast1 Unmanaged.repeat_interleave_t
+
+repeat_interleave_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_ttll = _cast4 Unmanaged.repeat_interleave_ttll
+
+repeat_interleave_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_ttl = _cast3 Unmanaged.repeat_interleave_ttl
+
+repeat_interleave_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_tt = _cast2 Unmanaged.repeat_interleave_tt
+
+repeat_interleave_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_tlll = _cast4 Unmanaged.repeat_interleave_tlll
+
+repeat_interleave_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+repeat_interleave_tll = _cast3 Unmanaged.repeat_interleave_tll
+
+reshape_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reshape_tl = _cast2 Unmanaged.reshape_tl
+
+_reshape_copy_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_reshape_copy_tl = _cast2 Unmanaged._reshape_copy_tl
+
+_reshape_alias_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_reshape_alias_tll = _cast3 Unmanaged._reshape_alias_tll
+
+_mkldnn_reshape_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_mkldnn_reshape_tl = _cast2 Unmanaged._mkldnn_reshape_tl
+
+round_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+round_t = _cast1 Unmanaged.round_t
+
+round__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+round__t = _cast1 Unmanaged.round__t
+
+round_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+round_out_tt = _cast2 Unmanaged.round_out_tt
+
+round_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+round_tl = _cast2 Unmanaged.round_tl
+
+round__tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+round__tl = _cast2 Unmanaged.round__tl
+
+round_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+round_out_ttl = _cast3 Unmanaged.round_out_ttl
+
+rrelu_tssbG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+rrelu_tssbG = _cast5 Unmanaged.rrelu_tssbG
+
+rrelu_tssb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+rrelu_tssb = _cast4 Unmanaged.rrelu_tssb
+
+rrelu_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu_tss = _cast3 Unmanaged.rrelu_tss
+
+rrelu_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu_ts = _cast2 Unmanaged.rrelu_ts
+
+rrelu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rrelu_t = _cast1 Unmanaged.rrelu_t
+
+rrelu__tssbG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+rrelu__tssbG = _cast5 Unmanaged.rrelu__tssbG
+
+rrelu__tssb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+rrelu__tssb = _cast4 Unmanaged.rrelu__tssb
+
+rrelu__tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu__tss = _cast3 Unmanaged.rrelu__tss
+
+rrelu__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu__ts = _cast2 Unmanaged.rrelu__ts
+
+rrelu__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rrelu__t = _cast1 Unmanaged.rrelu__t
+
+relu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+relu_t = _cast1 Unmanaged.relu_t
+
+relu__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+relu__t = _cast1 Unmanaged.relu__t
+
+relu6_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+relu6_t = _cast1 Unmanaged.relu6_t
+
+relu6__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+relu6__t = _cast1 Unmanaged.relu6__t
+
+prelu_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+prelu_tt = _cast2 Unmanaged.prelu_tt
+
+_prelu_kernel_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_prelu_kernel_tt = _cast2 Unmanaged._prelu_kernel_tt
+
+_prelu_kernel_backward_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_prelu_kernel_backward_ttt = _cast3 Unmanaged._prelu_kernel_backward_ttt
+
+gelu_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+gelu_out_tts = _cast3 Unmanaged.gelu_out_tts
+
+gelu_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gelu_out_tt = _cast2 Unmanaged.gelu_out_tt
+
+gelu__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+gelu__ts = _cast2 Unmanaged.gelu__ts
+
+gelu__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gelu__t = _cast1 Unmanaged.gelu__t
+
+gelu_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+gelu_ts = _cast2 Unmanaged.gelu_ts
+
+gelu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gelu_t = _cast1 Unmanaged.gelu_t
+
+gelu_backward_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+gelu_backward_out_ttts = _cast4 Unmanaged.gelu_backward_out_ttts
+
+gelu_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gelu_backward_out_ttt = _cast3 Unmanaged.gelu_backward_out_ttt
+
+gelu_backward_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+gelu_backward_tts = _cast3 Unmanaged.gelu_backward_tts
+
+gelu_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gelu_backward_tt = _cast2 Unmanaged.gelu_backward_tt
+
+infinitely_differentiable_gelu_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+infinitely_differentiable_gelu_backward_tt = _cast2 Unmanaged.infinitely_differentiable_gelu_backward_tt
+
+hardshrink_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardshrink_out_tts = _cast3 Unmanaged.hardshrink_out_tts
+
+hardshrink_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardshrink_out_tt = _cast2 Unmanaged.hardshrink_out_tt
+
+hardshrink_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardshrink_ts = _cast2 Unmanaged.hardshrink_ts
+
+hardshrink_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardshrink_t = _cast1 Unmanaged.hardshrink_t
+
+hardshrink_backward_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardshrink_backward_out_ttts = _cast4 Unmanaged.hardshrink_backward_out_ttts
+
+hardshrink_backward_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardshrink_backward_tts = _cast3 Unmanaged.hardshrink_backward_tts
+
+rsqrt_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rsqrt_t = _cast1 Unmanaged.rsqrt_t
+
+rsqrt__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rsqrt__t = _cast1 Unmanaged.rsqrt__t
+
+rsqrt_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rsqrt_out_tt = _cast2 Unmanaged.rsqrt_out_tt
+
+select_tnl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+select_tnl = _cast3 Unmanaged.select_tnl
+
+select_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+select_tll = _cast3 Unmanaged.select_tll
+
+select_backward_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+select_backward_tlll = _cast4 Unmanaged.select_backward_tlll
+
+_nested_select_backward_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_nested_select_backward_ttll = _cast4 Unmanaged._nested_select_backward_ttll
+
+selu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+selu_t = _cast1 Unmanaged.selu_t
+
+selu__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+selu__t = _cast1 Unmanaged.selu__t
+
+celu_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+celu_ts = _cast2 Unmanaged.celu_ts
+
+celu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+celu_t = _cast1 Unmanaged.celu_t
+
+celu__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+celu__ts = _cast2 Unmanaged.celu__ts
+
+celu__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+celu__t = _cast1 Unmanaged.celu__t
+
+silu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+silu_t = _cast1 Unmanaged.silu_t
+
+silu__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+silu__t = _cast1 Unmanaged.silu__t
+
+silu_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+silu_out_tt = _cast2 Unmanaged.silu_out_tt
+
+silu_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+silu_backward_out_ttt = _cast3 Unmanaged.silu_backward_out_ttt
+
+silu_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+silu_backward_tt = _cast2 Unmanaged.silu_backward_tt
+
+mish_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mish_t = _cast1 Unmanaged.mish_t
+
+mish__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mish__t = _cast1 Unmanaged.mish__t
+
+mish_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mish_out_tt = _cast2 Unmanaged.mish_out_tt
+
+mish_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mish_backward_tt = _cast2 Unmanaged.mish_backward_tt
+
+sigmoid_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sigmoid_t = _cast1 Unmanaged.sigmoid_t
+
+sigmoid__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sigmoid__t = _cast1 Unmanaged.sigmoid__t
+
+sigmoid_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sigmoid_out_tt = _cast2 Unmanaged.sigmoid_out_tt
+
+logit_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+logit_td = _cast2 Unmanaged.logit_td
+
+logit_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logit_t = _cast1 Unmanaged.logit_t
+
+logit__td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+logit__td = _cast2 Unmanaged.logit__td
+
+logit__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logit__t = _cast1 Unmanaged.logit__t
+
+logit_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+logit_out_ttd = _cast3 Unmanaged.logit_out_ttd
+
+logit_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+logit_out_tt = _cast2 Unmanaged.logit_out_tt
+
+sin_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sin_t = _cast1 Unmanaged.sin_t
+
+sin__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sin__t = _cast1 Unmanaged.sin__t
+
+sin_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sin_out_tt = _cast2 Unmanaged.sin_out_tt
+
+sinc_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sinc_t = _cast1 Unmanaged.sinc_t
+
+sinc__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sinc__t = _cast1 Unmanaged.sinc__t
+
+sinc_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sinc_out_tt = _cast2 Unmanaged.sinc_out_tt
+
+sinh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sinh_t = _cast1 Unmanaged.sinh_t
+
+sinh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sinh__t = _cast1 Unmanaged.sinh__t
+
+sinh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sinh_out_tt = _cast2 Unmanaged.sinh_out_tt
+
+detach_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+detach_t = _cast1 Unmanaged.detach_t
+
+detach__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+detach__t = _cast1 Unmanaged.detach__t
+
+size_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (Int64)
+size_tl = _cast2 Unmanaged.size_tl
+
+size_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (Int64)
+size_tn = _cast2 Unmanaged.size_tn
+
+slice_tllll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_tllll = _cast5 Unmanaged.slice_tllll
+
+slice_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_tlll = _cast4 Unmanaged.slice_tlll
+
+slice_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_tll = _cast3 Unmanaged.slice_tll
+
+slice_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_tl = _cast2 Unmanaged.slice_tl
+
+slice_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slice_t = _cast1 Unmanaged.slice_t
+
+slice_backward_tlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_backward_tlllll = _cast6 Unmanaged.slice_backward_tlllll
+
+slice_scatter_ttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_scatter_ttllll = _cast6 Unmanaged.slice_scatter_ttllll
+
+slice_scatter_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_scatter_ttlll = _cast5 Unmanaged.slice_scatter_ttlll
+
+slice_scatter_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_scatter_ttll = _cast4 Unmanaged.slice_scatter_ttll
+
+slice_scatter_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+slice_scatter_ttl = _cast3 Unmanaged.slice_scatter_ttl
+
+slice_scatter_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+slice_scatter_tt = _cast2 Unmanaged.slice_scatter_tt
+
+select_scatter_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+select_scatter_ttll = _cast4 Unmanaged.select_scatter_ttll
+
+diagonal_scatter_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_scatter_ttlll = _cast5 Unmanaged.diagonal_scatter_ttlll
+
+diagonal_scatter_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_scatter_ttll = _cast4 Unmanaged.diagonal_scatter_ttll
+
+diagonal_scatter_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diagonal_scatter_ttl = _cast3 Unmanaged.diagonal_scatter_ttl
+
+diagonal_scatter_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diagonal_scatter_tt = _cast2 Unmanaged.diagonal_scatter_tt
+
+as_strided_scatter_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+as_strided_scatter_ttlll = _cast5 Unmanaged.as_strided_scatter_ttlll
+
+as_strided_scatter_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+as_strided_scatter_ttll = _cast4 Unmanaged.as_strided_scatter_ttll
+
+smm_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+smm_tt = _cast2 Unmanaged.smm_tt
+
+softmax_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+softmax_tls = _cast3 Unmanaged.softmax_tls
+
+softmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+softmax_tl = _cast2 Unmanaged.softmax_tl
+
+softmax_out_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+softmax_out_ttls = _cast4 Unmanaged.softmax_out_ttls
+
+softmax_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+softmax_out_ttl = _cast3 Unmanaged.softmax_out_ttl
+
+softmax_tns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+softmax_tns = _cast3 Unmanaged.softmax_tns
+
+softmax_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+softmax_tn = _cast2 Unmanaged.softmax_tn
+
+_softmax_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_softmax_tlb = _cast3 Unmanaged._softmax_tlb
+
+_softmax_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_softmax_out_ttlb = _cast4 Unmanaged._softmax_out_ttlb
+
+_softmax_backward_data_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_softmax_backward_data_ttls = _cast4 Unmanaged._softmax_backward_data_ttls
+
+_softmax_backward_data_out_tttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_softmax_backward_data_out_tttls = _cast5 Unmanaged._softmax_backward_data_out_tttls
+
+unsafe_split_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+unsafe_split_tll = _cast3 Unmanaged.unsafe_split_tll
+
+unsafe_split_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+unsafe_split_tl = _cast2 Unmanaged.unsafe_split_tl
+
+split_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+split_tll = _cast3 Unmanaged.split_tll
+
+split_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+split_tl = _cast2 Unmanaged.split_tl
+
+unsafe_split_with_sizes_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+unsafe_split_with_sizes_tll = _cast3 Unmanaged.unsafe_split_with_sizes_tll
+
+unsafe_split_with_sizes_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr TensorList)
+unsafe_split_with_sizes_tl = _cast2 Unmanaged.unsafe_split_with_sizes_tl
+
+split_with_sizes_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+split_with_sizes_tll = _cast3 Unmanaged.split_with_sizes_tll
+
+split_with_sizes_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr TensorList)
+split_with_sizes_tl = _cast2 Unmanaged.split_with_sizes_tl
+
+hsplit_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+hsplit_tl = _cast2 Unmanaged.hsplit_tl
+
+vsplit_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+vsplit_tl = _cast2 Unmanaged.vsplit_tl
+
+dsplit_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+dsplit_tl = _cast2 Unmanaged.dsplit_tl
+
+squeeze_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+squeeze_t = _cast1 Unmanaged.squeeze_t
+
+squeeze_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+squeeze_tl = _cast2 Unmanaged.squeeze_tl
+
+squeeze_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+squeeze_tn = _cast2 Unmanaged.squeeze_tn
+
+sspaddmm_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sspaddmm_tttss = _cast5 Unmanaged.sspaddmm_tttss
+
+sspaddmm_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sspaddmm_ttts = _cast4 Unmanaged.sspaddmm_ttts
+
+sspaddmm_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sspaddmm_ttt = _cast3 Unmanaged.sspaddmm_ttt
+
+sspaddmm_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sspaddmm_out_ttttss = _cast6 Unmanaged.sspaddmm_out_ttttss
+
+sspaddmm_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sspaddmm_out_tttts = _cast5 Unmanaged.sspaddmm_out_tttts
+
+sspaddmm_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sspaddmm_out_tttt = _cast4 Unmanaged.sspaddmm_out_tttt
+
+stack_ll
+  :: ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+stack_ll = _cast2 Unmanaged.stack_ll
+
+stack_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+stack_l = _cast1 Unmanaged.stack_l
+
+stack_out_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+stack_out_tll = _cast3 Unmanaged.stack_out_tll
+
+stack_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+stack_out_tl = _cast2 Unmanaged.stack_out_tl
+
+_stack_ll
+  :: ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_stack_ll = _cast2 Unmanaged._stack_ll
+
+_stack_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+_stack_l = _cast1 Unmanaged._stack_l
+
+_stack_out_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_stack_out_tll = _cast3 Unmanaged._stack_out_tll
+
+_stack_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+_stack_out_tl = _cast2 Unmanaged._stack_out_tl
+
+hstack_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+hstack_l = _cast1 Unmanaged.hstack_l
+
+hstack_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+hstack_out_tl = _cast2 Unmanaged.hstack_out_tl
+
+vstack_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+vstack_l = _cast1 Unmanaged.vstack_l
+
+vstack_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+vstack_out_tl = _cast2 Unmanaged.vstack_out_tl
+
+dstack_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+dstack_l = _cast1 Unmanaged.dstack_l
+
+dstack_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+dstack_out_tl = _cast2 Unmanaged.dstack_out_tl
+
+stft_tllltbbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+stft_tllltbbb = _cast8 Unmanaged.stft_tllltbbb
+
+stft_tllltbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+stft_tllltbb = _cast7 Unmanaged.stft_tllltbb
+
+-- stft_tllltb
+--   :: ForeignPtr Tensor
+--   -> Int64
+--   -> Int64
+--   -> Int64
+--   -> ForeignPtr Tensor
+--   -> CBool
+--   -> IO (ForeignPtr Tensor)
+-- stft_tllltb = _cast6 Unmanaged.stft_tllltb
+
+stft_tlllt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+stft_tlllt = _cast5 Unmanaged.stft_tlllt
+
+stft_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+stft_tlll = _cast4 Unmanaged.stft_tlll
+
+stft_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+stft_tll = _cast3 Unmanaged.stft_tll
+
+stft_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+stft_tl = _cast2 Unmanaged.stft_tl
+
+stft_tllltbsbbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr StdString
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+stft_tllltbsbbb = _cast10 Unmanaged.stft_tllltbsbbb
+
+stft_tllltbsbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr StdString
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+stft_tllltbsbb = _cast9 Unmanaged.stft_tllltbsbb
+
+stft_tllltbsb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+stft_tllltbsb = _cast8 Unmanaged.stft_tllltbsb
+
+stft_tllltbs
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+stft_tllltbs = _cast7 Unmanaged.stft_tllltbs
+
+istft_tllltbbblb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+istft_tllltbbblb = _cast10 Unmanaged.istft_tllltbbblb
+
+istft_tllltbbbl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+istft_tllltbbbl = _cast9 Unmanaged.istft_tllltbbbl
+
+istft_tllltbbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+istft_tllltbbb = _cast8 Unmanaged.istft_tllltbbb
+
+istft_tllltbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+istft_tllltbb = _cast7 Unmanaged.istft_tllltbb
+
+istft_tllltb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+istft_tllltb = _cast6 Unmanaged.istft_tllltb
+
+istft_tlllt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+istft_tlllt = _cast5 Unmanaged.istft_tlllt
+
+istft_tlll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+istft_tlll = _cast4 Unmanaged.istft_tlll
+
+istft_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+istft_tll = _cast3 Unmanaged.istft_tll
+
+istft_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+istft_tl = _cast2 Unmanaged.istft_tl
+
+stride_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (Int64)
+stride_tl = _cast2 Unmanaged.stride_tl
+
+stride_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (Int64)
+stride_tn = _cast2 Unmanaged.stride_tn
+
+sum_ts
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+sum_ts = _cast2 Unmanaged.sum_ts
+
+sum_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sum_t = _cast1 Unmanaged.sum_t
+
+sum_tlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+sum_tlbs = _cast4 Unmanaged.sum_tlbs
+
+sum_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+sum_tlb = _cast3 Unmanaged.sum_tlb
+
+sum_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+sum_tl = _cast2 Unmanaged.sum_tl
+
+sum_tNbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+sum_tNbs = _cast4 Unmanaged.sum_tNbs
+
+sum_tNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+sum_tNb = _cast3 Unmanaged.sum_tNb
+
+sum_tN
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+sum_tN = _cast2 Unmanaged.sum_tN
+
+sum_out_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+sum_out_ttlbs = _cast5 Unmanaged.sum_out_ttlbs
+
+sum_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+sum_out_ttlb = _cast4 Unmanaged.sum_out_ttlb
+
+sum_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+sum_out_ttl = _cast3 Unmanaged.sum_out_ttl
+
+sum_out_ttNbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+sum_out_ttNbs = _cast5 Unmanaged.sum_out_ttNbs
+
+sum_out_ttNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+sum_out_ttNb = _cast4 Unmanaged.sum_out_ttNb
+
+sum_out_ttN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+sum_out_ttN = _cast3 Unmanaged.sum_out_ttN
+
+_nested_sum_backward_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_nested_sum_backward_ttlb = _cast4 Unmanaged._nested_sum_backward_ttlb
+
+_nested_sum_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_nested_sum_backward_ttl = _cast3 Unmanaged._nested_sum_backward_ttl
+
+nansum_tlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+nansum_tlbs = _cast4 Unmanaged.nansum_tlbs
+
+nansum_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nansum_tlb = _cast3 Unmanaged.nansum_tlb
+
+nansum_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+nansum_tl = _cast2 Unmanaged.nansum_tl
+
+nansum_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nansum_t = _cast1 Unmanaged.nansum_t
+
+nansum_out_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+nansum_out_ttlbs = _cast5 Unmanaged.nansum_out_ttlbs
+
+nansum_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nansum_out_ttlb = _cast4 Unmanaged.nansum_out_ttlb
+
+nansum_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+nansum_out_ttl = _cast3 Unmanaged.nansum_out_ttl
+
+nansum_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nansum_out_tt = _cast2 Unmanaged.nansum_out_tt
+
+sqrt_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sqrt_t = _cast1 Unmanaged.sqrt_t
+
+sqrt__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sqrt__t = _cast1 Unmanaged.sqrt__t
+
+sqrt_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> 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
+
+square_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+square_out_tt = _cast2 Unmanaged.square_out_tt
+
+std_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_tb = _cast2 Unmanaged.std_tb
+
+std_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+std_t = _cast1 Unmanaged.std_t
+
+std_tlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_tlbb = _cast4 Unmanaged.std_tlbb
+
diff --git a/src/Torch/Internal/Managed/Native/Native5.hs b/src/Torch/Internal/Managed/Native/Native5.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native5.hs
@@ -0,0 +1,1909 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native5 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native5 as Unmanaged
+
+
+std_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_tlb = _cast3 Unmanaged.std_tlb
+
+std_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+std_tl = _cast2 Unmanaged.std_tl
+
+std_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_tllb = _cast4 Unmanaged.std_tllb
+
+std_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+std_tll = _cast3 Unmanaged.std_tll
+
+-- std_t
+--   :: ForeignPtr Tensor
+--   -> IO (ForeignPtr Tensor)
+-- std_t = _cast1 Unmanaged.std_t
+
+std_mean_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tb = _cast2 Unmanaged.std_mean_tb
+
+std_mean_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_t = _cast1 Unmanaged.std_mean_t
+
+std_mean_tlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tlbb = _cast4 Unmanaged.std_mean_tlbb
+
+std_mean_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tlb = _cast3 Unmanaged.std_mean_tlb
+
+std_mean_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tl = _cast2 Unmanaged.std_mean_tl
+
+std_mean_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tllb = _cast4 Unmanaged.std_mean_tllb
+
+std_mean_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tll = _cast3 Unmanaged.std_mean_tll
+
+std_mean_tNbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tNbb = _cast4 Unmanaged.std_mean_tNbb
+
+std_mean_tNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tNb = _cast3 Unmanaged.std_mean_tNb
+
+std_mean_tN
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tN = _cast2 Unmanaged.std_mean_tN
+
+std_mean_tNlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tNlb = _cast4 Unmanaged.std_mean_tNlb
+
+std_mean_tNl
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+std_mean_tNl = _cast3 Unmanaged.std_mean_tNl
+
+std_out_ttlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_out_ttlbb = _cast5 Unmanaged.std_out_ttlbb
+
+std_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_out_ttlb = _cast4 Unmanaged.std_out_ttlb
+
+std_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+std_out_ttl = _cast3 Unmanaged.std_out_ttl
+
+std_out_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_out_ttllb = _cast5 Unmanaged.std_out_ttllb
+
+std_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+std_out_ttll = _cast4 Unmanaged.std_out_ttll
+
+std_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+std_out_tt = _cast2 Unmanaged.std_out_tt
+
+std_tNbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_tNbb = _cast4 Unmanaged.std_tNbb
+
+std_tNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_tNb = _cast3 Unmanaged.std_tNb
+
+std_tN
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+std_tN = _cast2 Unmanaged.std_tN
+
+std_out_ttNbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_out_ttNbb = _cast5 Unmanaged.std_out_ttNbb
+
+std_out_ttNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_out_ttNb = _cast4 Unmanaged.std_out_ttNb
+
+std_out_ttN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+std_out_ttN = _cast3 Unmanaged.std_out_ttN
+
+std_tNlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_tNlb = _cast4 Unmanaged.std_tNlb
+
+std_tNl
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+std_tNl = _cast3 Unmanaged.std_tNl
+
+std_out_ttNlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+std_out_ttNlb = _cast5 Unmanaged.std_out_ttNlb
+
+std_out_ttNl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+std_out_ttNl = _cast4 Unmanaged.std_out_ttNl
+
+prod_ts
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+prod_ts = _cast2 Unmanaged.prod_ts
+
+prod_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+prod_t = _cast1 Unmanaged.prod_t
+
+prod_tlbs
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+prod_tlbs = _cast4 Unmanaged.prod_tlbs
+
+prod_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+prod_tlb = _cast3 Unmanaged.prod_tlb
+
+prod_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+prod_tl = _cast2 Unmanaged.prod_tl
+
+prod_out_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+prod_out_ttlbs = _cast5 Unmanaged.prod_out_ttlbs
+
+prod_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+prod_out_ttlb = _cast4 Unmanaged.prod_out_ttlb
+
+prod_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+prod_out_ttl = _cast3 Unmanaged.prod_out_ttl
+
+prod_tnbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+prod_tnbs = _cast4 Unmanaged.prod_tnbs
+
+prod_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+prod_tnb = _cast3 Unmanaged.prod_tnb
+
+prod_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+prod_tn = _cast2 Unmanaged.prod_tn
+
+prod_out_ttnbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+prod_out_ttnbs = _cast5 Unmanaged.prod_out_ttnbs
+
+prod_out_ttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+prod_out_ttnb = _cast4 Unmanaged.prod_out_ttnb
+
+prod_out_ttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+prod_out_ttn = _cast3 Unmanaged.prod_out_ttn
+
+t_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+t_t = _cast1 Unmanaged.t_t
+
+tan_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tan_t = _cast1 Unmanaged.tan_t
+
+tan__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tan__t = _cast1 Unmanaged.tan__t
+
+tan_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tan_out_tt = _cast2 Unmanaged.tan_out_tt
+
+tanh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tanh_t = _cast1 Unmanaged.tanh_t
+
+tanh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tanh__t = _cast1 Unmanaged.tanh__t
+
+tanh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tanh_out_tt = _cast2 Unmanaged.tanh_out_tt
+
+tensordot_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensordot_ttll = _cast4 Unmanaged.tensordot_ttll
+
+tensordot_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensordot_out_tttll = _cast5 Unmanaged.tensordot_out_tttll
+
+threshold_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+threshold_tss = _cast3 Unmanaged.threshold_tss
+
+threshold__tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+threshold__tss = _cast3 Unmanaged.threshold__tss
+
+threshold_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+threshold_out_ttss = _cast4 Unmanaged.threshold_out_ttss
+
+threshold_backward_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+threshold_backward_out_ttts = _cast4 Unmanaged.threshold_backward_out_ttts
+
+threshold_backward_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+threshold_backward_tts = _cast3 Unmanaged.threshold_backward_tts
+
+tile_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tile_tl = _cast2 Unmanaged.tile_tl
+
+transpose_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+transpose_tll = _cast3 Unmanaged.transpose_tll
+
+transpose_tnn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+transpose_tnn = _cast3 Unmanaged.transpose_tnn
+
+_mkldnn_transpose_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_mkldnn_transpose_tll = _cast3 Unmanaged._mkldnn_transpose_tll
+
+_mkldnn_transpose__tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_mkldnn_transpose__tll = _cast3 Unmanaged._mkldnn_transpose__tll
+
+one_hot_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+one_hot_tl = _cast2 Unmanaged.one_hot_tl
+
+one_hot_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+one_hot_t = _cast1 Unmanaged.one_hot_t
+
+flip_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+flip_tl = _cast2 Unmanaged.flip_tl
+
+fliplr_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fliplr_t = _cast1 Unmanaged.fliplr_t
+
+flipud_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+flipud_t = _cast1 Unmanaged.flipud_t
+
+roll_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+roll_tll = _cast3 Unmanaged.roll_tll
+
+roll_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+roll_tl = _cast2 Unmanaged.roll_tl
+
+rot90_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+rot90_tll = _cast3 Unmanaged.rot90_tll
+
+rot90_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+rot90_tl = _cast2 Unmanaged.rot90_tl
+
+rot90_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rot90_t = _cast1 Unmanaged.rot90_t
+
+trapezoid_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+trapezoid_ttl = _cast3 Unmanaged.trapezoid_ttl
+
+trapezoid_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trapezoid_tt = _cast2 Unmanaged.trapezoid_tt
+
+trapezoid_tsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+trapezoid_tsl = _cast3 Unmanaged.trapezoid_tsl
+
+trapezoid_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+trapezoid_ts = _cast2 Unmanaged.trapezoid_ts
+
+trapezoid_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trapezoid_t = _cast1 Unmanaged.trapezoid_t
+
+trapz_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+trapz_ttl = _cast3 Unmanaged.trapz_ttl
+
+trapz_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trapz_tt = _cast2 Unmanaged.trapz_tt
+
+trapz_tdl
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+trapz_tdl = _cast3 Unmanaged.trapz_tdl
+
+trapz_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+trapz_td = _cast2 Unmanaged.trapz_td
+
+trapz_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trapz_t = _cast1 Unmanaged.trapz_t
+
+_transform_bias_rescale_qkv_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_transform_bias_rescale_qkv_ttl = _cast3 Unmanaged._transform_bias_rescale_qkv_ttl
+
+_nested_tensor_from_mask_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_mask_ttb = _cast3 Unmanaged._nested_tensor_from_mask_ttb
+
+_nested_tensor_from_mask_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_tensor_from_mask_tt = _cast2 Unmanaged._nested_tensor_from_mask_tt
+
+_nested_tensor_from_mask_left_aligned_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+_nested_tensor_from_mask_left_aligned_tt = _cast2 Unmanaged._nested_tensor_from_mask_left_aligned_tt
+
+_nested_from_padded_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_nested_from_padded_ttb = _cast3 Unmanaged._nested_from_padded_ttb
+
+_nested_from_padded_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_from_padded_tt = _cast2 Unmanaged._nested_from_padded_tt
+
+_nested_from_padded_and_nested_example_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_nested_from_padded_and_nested_example_tt = _cast2 Unmanaged._nested_from_padded_and_nested_example_tt
+
+_trilinear_tttlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_trilinear_tttlllll = _cast8 Unmanaged._trilinear_tttlllll
+
+_trilinear_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_trilinear_tttllll = _cast7 Unmanaged._trilinear_tttllll
+
+triplet_margin_loss_tttdddbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triplet_margin_loss_tttdddbl = _cast8 Unmanaged.triplet_margin_loss_tttdddbl
+
+triplet_margin_loss_tttdddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+triplet_margin_loss_tttdddb = _cast7 Unmanaged.triplet_margin_loss_tttdddb
+
+triplet_margin_loss_tttddd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+triplet_margin_loss_tttddd = _cast6 Unmanaged.triplet_margin_loss_tttddd
+
+triplet_margin_loss_tttdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+triplet_margin_loss_tttdd = _cast5 Unmanaged.triplet_margin_loss_tttdd
+
+triplet_margin_loss_tttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+triplet_margin_loss_tttd = _cast4 Unmanaged.triplet_margin_loss_tttd
+
+triplet_margin_loss_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+triplet_margin_loss_ttt = _cast3 Unmanaged.triplet_margin_loss_ttt
+
+trunc_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trunc_t = _cast1 Unmanaged.trunc_t
+
+trunc__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trunc__t = _cast1 Unmanaged.trunc__t
+
+trunc_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trunc_out_tt = _cast2 Unmanaged.trunc_out_tt
+
+fix_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fix_t = _cast1 Unmanaged.fix_t
+
+fix__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fix__t = _cast1 Unmanaged.fix__t
+
+fix_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fix_out_tt = _cast2 Unmanaged.fix_out_tt
+
+_has_compatible_shallow_copy_type_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+_has_compatible_shallow_copy_type_tt = _cast2 Unmanaged._has_compatible_shallow_copy_type_tt
+
+_unique_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_unique_tbb = _cast3 Unmanaged._unique_tbb
+
+_unique_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_unique_tb = _cast2 Unmanaged._unique_tb
+
+_unique_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_unique_t = _cast1 Unmanaged._unique_t
+
+unique_dim_tlbbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_tlbbb = _cast5 Unmanaged.unique_dim_tlbbb
+
+unique_dim_tlbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_tlbb = _cast4 Unmanaged.unique_dim_tlbb
+
+unique_dim_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_tlb = _cast3 Unmanaged.unique_dim_tlb
+
+unique_dim_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_tl = _cast2 Unmanaged.unique_dim_tl
+
+unique_consecutive_tbbl
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_tbbl = _cast4 Unmanaged.unique_consecutive_tbbl
+
+unique_consecutive_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_tbb = _cast3 Unmanaged.unique_consecutive_tbb
+
+unique_consecutive_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_tb = _cast2 Unmanaged.unique_consecutive_tb
+
+unique_consecutive_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_t = _cast1 Unmanaged.unique_consecutive_t
+
+unique_dim_consecutive_tlbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_tlbb = _cast4 Unmanaged.unique_dim_consecutive_tlbb
+
+unique_dim_consecutive_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_tlb = _cast3 Unmanaged.unique_dim_consecutive_tlb
+
+unique_dim_consecutive_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_tl = _cast2 Unmanaged.unique_dim_consecutive_tl
+
+_unique2_tbbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_tbbb = _cast4 Unmanaged._unique2_tbbb
+
+_unique2_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_tbb = _cast3 Unmanaged._unique2_tbb
+
+_unique2_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_tb = _cast2 Unmanaged._unique2_tb
+
+_unique2_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_t = _cast1 Unmanaged._unique2_t
+
+_unsafe_view_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_unsafe_view_tl = _cast2 Unmanaged._unsafe_view_tl
+
+unsqueeze_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+unsqueeze_tl = _cast2 Unmanaged.unsqueeze_tl
+
+vander_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+vander_tlb = _cast3 Unmanaged.vander_tlb
+
+vander_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+vander_tl = _cast2 Unmanaged.vander_tl
+
+vander_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+vander_t = _cast1 Unmanaged.vander_t
+
+var_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_tb = _cast2 Unmanaged.var_tb
+
+var_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+var_t = _cast1 Unmanaged.var_t
+
+var_tlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_tlbb = _cast4 Unmanaged.var_tlbb
+
+var_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_tlb = _cast3 Unmanaged.var_tlb
+
+var_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+var_tl = _cast2 Unmanaged.var_tl
+
+var_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_tllb = _cast4 Unmanaged.var_tllb
+
+var_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+var_tll = _cast3 Unmanaged.var_tll
+
+var_out_ttlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_out_ttlbb = _cast5 Unmanaged.var_out_ttlbb
+
+var_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_out_ttlb = _cast4 Unmanaged.var_out_ttlb
+
+var_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+var_out_ttl = _cast3 Unmanaged.var_out_ttl
+
+var_out_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_out_ttllb = _cast5 Unmanaged.var_out_ttllb
+
+var_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+var_out_ttll = _cast4 Unmanaged.var_out_ttll
+
+var_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+var_out_tt = _cast2 Unmanaged.var_out_tt
+
+var_tNbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_tNbb = _cast4 Unmanaged.var_tNbb
+
+var_tNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_tNb = _cast3 Unmanaged.var_tNb
+
+var_tN
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+var_tN = _cast2 Unmanaged.var_tN
+
+var_out_ttNbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_out_ttNbb = _cast5 Unmanaged.var_out_ttNbb
+
+var_out_ttNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_out_ttNb = _cast4 Unmanaged.var_out_ttNb
+
+var_out_ttN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+var_out_ttN = _cast3 Unmanaged.var_out_ttN
+
+var_tNlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_tNlb = _cast4 Unmanaged.var_tNlb
+
+var_tNl
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+var_tNl = _cast3 Unmanaged.var_tNl
+
+var_out_ttNlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+var_out_ttNlb = _cast5 Unmanaged.var_out_ttNlb
+
+var_out_ttNl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+var_out_ttNl = _cast4 Unmanaged.var_out_ttNl
+
+var_mean_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tb = _cast2 Unmanaged.var_mean_tb
+
+var_mean_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_t = _cast1 Unmanaged.var_mean_t
+
+var_mean_tlbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tlbb = _cast4 Unmanaged.var_mean_tlbb
+
+var_mean_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tlb = _cast3 Unmanaged.var_mean_tlb
+
+var_mean_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tl = _cast2 Unmanaged.var_mean_tl
+
+var_mean_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tllb = _cast4 Unmanaged.var_mean_tllb
+
+var_mean_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tll = _cast3 Unmanaged.var_mean_tll
+
+var_mean_tNbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tNbb = _cast4 Unmanaged.var_mean_tNbb
+
+var_mean_tNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tNb = _cast3 Unmanaged.var_mean_tNb
+
+var_mean_tN
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tN = _cast2 Unmanaged.var_mean_tN
+
+var_mean_tNlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tNlb = _cast4 Unmanaged.var_mean_tNlb
+
+var_mean_tNl
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+var_mean_tNl = _cast3 Unmanaged.var_mean_tNl
+
+where_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+where_ttt = _cast3 Unmanaged.where_ttt
+
+where_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+where_out_tttt = _cast4 Unmanaged.where_out_tttt
+
+where_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+where_tst = _cast3 Unmanaged.where_tst
+
+where_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+where_tts = _cast3 Unmanaged.where_tts
+
+where_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+where_tss = _cast3 Unmanaged.where_tss
+
+where_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+where_t = _cast1 Unmanaged.where_t
+
+norm_except_dim_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+norm_except_dim_tll = _cast3 Unmanaged.norm_except_dim_tll
+
+norm_except_dim_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+norm_except_dim_tl = _cast2 Unmanaged.norm_except_dim_tl
+
+norm_except_dim_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+norm_except_dim_t = _cast1 Unmanaged.norm_except_dim_t
+
+_weight_norm_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_weight_norm_ttl = _cast3 Unmanaged._weight_norm_ttl
+
+_weight_norm_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_weight_norm_tt = _cast2 Unmanaged._weight_norm_tt
+
+_weight_norm_interface_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_ttl = _cast3 Unmanaged._weight_norm_interface_ttl
+
+_weight_norm_interface_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_tt = _cast2 Unmanaged._weight_norm_interface_tt
+
+_weight_norm_interface_backward_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_backward_ttttl = _cast5 Unmanaged._weight_norm_interface_backward_ttttl
+
+_weight_norm_differentiable_backward_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_weight_norm_differentiable_backward_ttttl = _cast5 Unmanaged._weight_norm_differentiable_backward_ttttl
+
+zeros_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+zeros_lNo = _cast3 Unmanaged.zeros_lNo
+
+zeros_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+zeros_lN = _cast2 Unmanaged.zeros_lN
+
+_efficientzerotensor_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_efficientzerotensor_lo = _cast2 Unmanaged._efficientzerotensor_lo
+
+_efficientzerotensor_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_efficientzerotensor_l = _cast1 Unmanaged._efficientzerotensor_l
+
+zeros_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+zeros_lo = _cast2 Unmanaged.zeros_lo
+
+zeros_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+zeros_l = _cast1 Unmanaged.zeros_l
+
+zeros_out_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+zeros_out_tl = _cast2 Unmanaged.zeros_out_tl
+
+zeros_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+zeros_like_toM = _cast3 Unmanaged.zeros_like_toM
+
+zeros_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> IO (ForeignPtr Tensor)
+_standard_gamma_grad_tt = _cast2 Unmanaged._standard_gamma_grad_tt
+
+_standard_gamma_tG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+_standard_gamma_tG = _cast2 Unmanaged._standard_gamma_tG
+
+_standard_gamma_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_standard_gamma_t = _cast1 Unmanaged._standard_gamma_t
+
+_dirichlet_grad_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_dirichlet_grad_ttt = _cast3 Unmanaged._dirichlet_grad_ttt
+
+_sample_dirichlet_tG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+_sample_dirichlet_tG = _cast2 Unmanaged._sample_dirichlet_tG
+
+_sample_dirichlet_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sample_dirichlet_t = _cast1 Unmanaged._sample_dirichlet_t
+
+poisson_tG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+poisson_tG = _cast2 Unmanaged.poisson_tG
+
+poisson_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+poisson_t = _cast1 Unmanaged.poisson_t
+
+binomial_ttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+binomial_ttG = _cast3 Unmanaged.binomial_ttG
+
+binomial_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+binomial_tt = _cast2 Unmanaged.binomial_tt
+
+native_norm_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+native_norm_ts = _cast2 Unmanaged.native_norm_ts
+
+native_norm_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+native_norm_t = _cast1 Unmanaged.native_norm_t
+
+native_norm_tslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+native_norm_tslbs = _cast5 Unmanaged.native_norm_tslbs
+
+_sparse_sum_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_sum_t = _cast1 Unmanaged._sparse_sum_t
+
+_sparse_sum_ts
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_sum_ts = _cast2 Unmanaged._sparse_sum_ts
+
+_sparse_sum_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_sum_tl = _cast2 Unmanaged._sparse_sum_tl
+
+_sparse_sum_tls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_sum_tls = _cast3 Unmanaged._sparse_sum_tls
+
+_sparse_sum_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_sum_backward_ttl = _cast3 Unmanaged._sparse_sum_backward_ttl
+
+_sparse_csr_sum_tlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_sum_tlbs = _cast4 Unmanaged._sparse_csr_sum_tlbs
+
+_sparse_csr_sum_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_sum_tlb = _cast3 Unmanaged._sparse_csr_sum_tlb
+
+_sparse_csr_sum_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_sum_tl = _cast2 Unmanaged._sparse_csr_sum_tl
+
+_sparse_csr_prod_tlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_prod_tlbs = _cast4 Unmanaged._sparse_csr_prod_tlbs
+
+_sparse_csr_prod_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_prod_tlb = _cast3 Unmanaged._sparse_csr_prod_tlb
+
+_sparse_csr_prod_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_prod_tl = _cast2 Unmanaged._sparse_csr_prod_tl
+
+_sparse_softmax_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_softmax_tls = _cast3 Unmanaged._sparse_softmax_tls
+
+_sparse_softmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_sparse_softmax_tl = _cast2 Unmanaged._sparse_softmax_tl
+
+_sparse_softmax_tns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_softmax_tns = _cast3 Unmanaged._sparse_softmax_tns
+
+_sparse_softmax_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+_sparse_softmax_tn = _cast2 Unmanaged._sparse_softmax_tn
+
+_sparse_softmax_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_sparse_softmax_tlb = _cast3 Unmanaged._sparse_softmax_tlb
+
+_sparse_softmax_backward_data_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_softmax_backward_data_ttlt = _cast4 Unmanaged._sparse_softmax_backward_data_ttlt
+
+_sparse_log_softmax_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_log_softmax_tls = _cast3 Unmanaged._sparse_log_softmax_tls
+
+_sparse_log_softmax_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_sparse_log_softmax_tl = _cast2 Unmanaged._sparse_log_softmax_tl
+
+_sparse_log_softmax_tns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+_sparse_log_softmax_tns = _cast3 Unmanaged._sparse_log_softmax_tns
+
+_sparse_log_softmax_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+_sparse_log_softmax_tn = _cast2 Unmanaged._sparse_log_softmax_tn
+
+_sparse_log_softmax_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_sparse_log_softmax_tlb = _cast3 Unmanaged._sparse_log_softmax_tlb
+
+_sparse_log_softmax_backward_data_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_log_softmax_backward_data_ttlt = _cast4 Unmanaged._sparse_log_softmax_backward_data_ttlt
+
+_spdiags_ttlL
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Layout
+  -> IO (ForeignPtr Tensor)
+_spdiags_ttlL = _cast4 Unmanaged._spdiags_ttlL
+
+_spdiags_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_spdiags_ttl = _cast3 Unmanaged._spdiags_ttl
+
+norm_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+norm_tss = _cast3 Unmanaged.norm_tss
+
+norm_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+norm_ts = _cast2 Unmanaged.norm_ts
+
+norm_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+norm_t = _cast1 Unmanaged.norm_t
+
+norm_tslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+norm_tslbs = _cast5 Unmanaged.norm_tslbs
+
+norm_tslb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+norm_tslb = _cast4 Unmanaged.norm_tslb
+
+norm_tsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+norm_tsl = _cast3 Unmanaged.norm_tsl
+
+norm_out_ttslbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+norm_out_ttslbs = _cast6 Unmanaged.norm_out_ttslbs
+
+norm_out_ttslb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+norm_out_ttslb = _cast5 Unmanaged.norm_out_ttslb
+
+norm_out_ttsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+norm_out_ttsl = _cast4 Unmanaged.norm_out_ttsl
+
+norm_tsNbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+norm_tsNbs = _cast5 Unmanaged.norm_tsNbs
+
+norm_tsNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+norm_tsNb = _cast4 Unmanaged.norm_tsNb
+
+norm_tsN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+norm_tsN = _cast3 Unmanaged.norm_tsN
+
+norm_out_ttsNbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+norm_out_ttsNbs = _cast6 Unmanaged.norm_out_ttsNbs
+
+norm_out_ttsNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+norm_out_ttsNb = _cast5 Unmanaged.norm_out_ttsNb
+
+norm_out_ttsN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+norm_out_ttsN = _cast4 Unmanaged.norm_out_ttsN
+
+frexp_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+frexp_t = _cast1 Unmanaged.frexp_t
+
+frexp_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+frexp_out_ttt = _cast3 Unmanaged.frexp_out_ttt
+
+frobenius_norm_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+frobenius_norm_tlb = _cast3 Unmanaged.frobenius_norm_tlb
+
+frobenius_norm_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+frobenius_norm_tl = _cast2 Unmanaged.frobenius_norm_tl
+
+frobenius_norm_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+frobenius_norm_out_ttlb = _cast4 Unmanaged.frobenius_norm_out_ttlb
+
+frobenius_norm_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+frobenius_norm_out_ttl = _cast3 Unmanaged.frobenius_norm_out_ttl
+
+nuclear_norm_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nuclear_norm_tb = _cast2 Unmanaged.nuclear_norm_tb
+
+nuclear_norm_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nuclear_norm_t = _cast1 Unmanaged.nuclear_norm_t
+
+nuclear_norm_out_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nuclear_norm_out_ttb = _cast3 Unmanaged.nuclear_norm_out_ttb
+
+nuclear_norm_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nuclear_norm_out_tt = _cast2 Unmanaged.nuclear_norm_out_tt
+
+nuclear_norm_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nuclear_norm_tlb = _cast3 Unmanaged.nuclear_norm_tlb
+
+nuclear_norm_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+nuclear_norm_tl = _cast2 Unmanaged.nuclear_norm_tl
+
+nuclear_norm_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nuclear_norm_out_ttlb = _cast4 Unmanaged.nuclear_norm_out_ttlb
+
+nuclear_norm_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+nuclear_norm_out_ttl = _cast3 Unmanaged.nuclear_norm_out_ttl
+
+clone_tM
+  :: ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+clone_tM = _cast2 Unmanaged.clone_tM
+
+clone_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+clone_t = _cast1 Unmanaged.clone_t
+
+positive_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+positive_t = _cast1 Unmanaged.positive_t
+
+resize_as__ttM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+resize_as__ttM = _cast3 Unmanaged.resize_as__ttM
+
+resize_as__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+resize_as__tt = _cast2 Unmanaged.resize_as__tt
+
+resize_as_sparse__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+resize_as_sparse__tt = _cast2 Unmanaged.resize_as_sparse__tt
+
+zero__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+zero__t = _cast1 Unmanaged.zero__t
+
+sub_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sub_out_ttts = _cast4 Unmanaged.sub_out_ttts
+
+sub_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sub_out_ttt = _cast3 Unmanaged.sub_out_ttt
+
+sub_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sub_tts = _cast3 Unmanaged.sub_tts
+
+sub_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sub_tt = _cast2 Unmanaged.sub_tt
+
+sub_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sub_tss = _cast3 Unmanaged.sub_tss
+
+sub_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sub_ts = _cast2 Unmanaged.sub_ts
+
+subtract_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+subtract_out_ttts = _cast4 Unmanaged.subtract_out_ttts
+
+subtract_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+subtract_out_ttt = _cast3 Unmanaged.subtract_out_ttt
+
+subtract_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+subtract_tts = _cast3 Unmanaged.subtract_tts
+
+subtract_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+subtract_tt = _cast2 Unmanaged.subtract_tt
+
diff --git a/src/Torch/Internal/Managed/Native/Native6.hs b/src/Torch/Internal/Managed/Native/Native6.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native6.hs
@@ -0,0 +1,2384 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native6 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native6 as Unmanaged
+
+
+subtract_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+subtract_tss = _cast3 Unmanaged.subtract_tss
+
+subtract_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+subtract_ts = _cast2 Unmanaged.subtract_ts
+
+rsub_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rsub_tts = _cast3 Unmanaged.rsub_tts
+
+rsub_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rsub_tt = _cast2 Unmanaged.rsub_tt
+
+heaviside_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+heaviside_out_ttt = _cast3 Unmanaged.heaviside_out_ttt
+
+heaviside_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+heaviside_tt = _cast2 Unmanaged.heaviside_tt
+
+rsub_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rsub_tss = _cast3 Unmanaged.rsub_tss
+
+rsub_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rsub_ts = _cast2 Unmanaged.rsub_ts
+
+_sparse_addmm_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_sparse_addmm_tttss = _cast5 Unmanaged._sparse_addmm_tttss
+
+_sparse_addmm_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_sparse_addmm_ttts = _cast4 Unmanaged._sparse_addmm_ttts
+
+_sparse_addmm_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_sparse_addmm_ttt = _cast3 Unmanaged._sparse_addmm_ttt
+
+sparse_sampled_addmm_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sparse_sampled_addmm_out_ttttss = _cast6 Unmanaged.sparse_sampled_addmm_out_ttttss
+
+sparse_sampled_addmm_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sparse_sampled_addmm_out_tttts = _cast5 Unmanaged.sparse_sampled_addmm_out_tttts
+
+sparse_sampled_addmm_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sparse_sampled_addmm_out_tttt = _cast4 Unmanaged.sparse_sampled_addmm_out_tttt
+
+sparse_sampled_addmm_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sparse_sampled_addmm_tttss = _cast5 Unmanaged.sparse_sampled_addmm_tttss
+
+sparse_sampled_addmm_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+sparse_sampled_addmm_ttts = _cast4 Unmanaged.sparse_sampled_addmm_ttts
+
+sparse_sampled_addmm_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sparse_sampled_addmm_ttt = _cast3 Unmanaged.sparse_sampled_addmm_ttt
+
+_sparse_mm_reduce_impl_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_sparse_mm_reduce_impl_tts = _cast3 Unmanaged._sparse_mm_reduce_impl_tts
+
+_sparse_mm_reduce_impl_backward_tttsta
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> ForeignPtr (StdArray '(CBool,2))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_sparse_mm_reduce_impl_backward_tttsta = _cast6 Unmanaged._sparse_mm_reduce_impl_backward_tttsta
+
+addmm_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmm_out_ttttss = _cast6 Unmanaged.addmm_out_ttttss
+
+addmm_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmm_out_tttts = _cast5 Unmanaged.addmm_out_tttts
+
+addmm_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addmm_out_tttt = _cast4 Unmanaged.addmm_out_tttt
+
+addmm_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmm_tttss = _cast5 Unmanaged.addmm_tttss
+
+addmm_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addmm_ttts = _cast4 Unmanaged.addmm_ttts
+
+addmm_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addmm_ttt = _cast3 Unmanaged.addmm_ttt
+
+_addmm_activation_out_ttttssb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_addmm_activation_out_ttttssb = _cast7 Unmanaged._addmm_activation_out_ttttssb
+
+_addmm_activation_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_addmm_activation_out_ttttss = _cast6 Unmanaged._addmm_activation_out_ttttss
+
+_addmm_activation_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_addmm_activation_out_tttts = _cast5 Unmanaged._addmm_activation_out_tttts
+
+_addmm_activation_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_addmm_activation_out_tttt = _cast4 Unmanaged._addmm_activation_out_tttt
+
+_addmm_activation_tttssb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_addmm_activation_tttssb = _cast6 Unmanaged._addmm_activation_tttssb
+
+_addmm_activation_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_addmm_activation_tttss = _cast5 Unmanaged._addmm_activation_tttss
+
+_addmm_activation_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+_addmm_activation_ttts = _cast4 Unmanaged._addmm_activation_ttts
+
+_addmm_activation_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_addmm_activation_ttt = _cast3 Unmanaged._addmm_activation_ttt
+
+sparse_compressed_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_compressed_tensor_tttlo = _cast5 Unmanaged.sparse_compressed_tensor_tttlo
+
+sparse_csr_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_csr_tensor_tttlo = _cast5 Unmanaged.sparse_csr_tensor_tttlo
+
+sparse_csc_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_csc_tensor_tttlo = _cast5 Unmanaged.sparse_csc_tensor_tttlo
+
+sparse_bsr_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_bsr_tensor_tttlo = _cast5 Unmanaged.sparse_bsr_tensor_tttlo
+
+sparse_bsc_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_bsc_tensor_tttlo = _cast5 Unmanaged.sparse_bsc_tensor_tttlo
+
+sparse_compressed_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_compressed_tensor_ttto = _cast4 Unmanaged.sparse_compressed_tensor_ttto
+
+sparse_csr_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_csr_tensor_ttto = _cast4 Unmanaged.sparse_csr_tensor_ttto
+
+sparse_csc_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_csc_tensor_ttto = _cast4 Unmanaged.sparse_csc_tensor_ttto
+
+sparse_bsr_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_bsr_tensor_ttto = _cast4 Unmanaged.sparse_bsr_tensor_ttto
+
+sparse_bsc_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_bsc_tensor_ttto = _cast4 Unmanaged.sparse_bsc_tensor_ttto
+
+_sparse_compressed_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_compressed_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_compressed_tensor_unsafe_tttlo
+
+_sparse_compressed_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_compressed_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_compressed_tensor_unsafe_tttl
+
+_sparse_csr_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_csr_tensor_unsafe_tttlo
+
+_sparse_csr_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_csr_tensor_unsafe_tttl
+
+_sparse_csc_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_csc_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_csc_tensor_unsafe_tttlo
+
+_sparse_csc_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_csc_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_csc_tensor_unsafe_tttl
+
+_sparse_bsr_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_bsr_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_bsr_tensor_unsafe_tttlo
+
+_sparse_bsr_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_bsr_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_bsr_tensor_unsafe_tttl
+
+_sparse_bsc_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_bsc_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_bsc_tensor_unsafe_tttlo
+
+_sparse_bsc_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_bsc_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_bsc_tensor_unsafe_tttl
+
+sparse_coo_tensor_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_lo = _cast2 Unmanaged.sparse_coo_tensor_lo
+
+sparse_coo_tensor_tto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_tto = _cast3 Unmanaged.sparse_coo_tensor_tto
+
+sparse_coo_tensor_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_tt = _cast2 Unmanaged.sparse_coo_tensor_tt
+
+sparse_coo_tensor_ttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_ttlo = _cast4 Unmanaged.sparse_coo_tensor_ttlo
+
+sparse_coo_tensor_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_ttl = _cast3 Unmanaged.sparse_coo_tensor_ttl
+
+_sparse_coo_tensor_unsafe_ttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_unsafe_ttlo = _cast4 Unmanaged._sparse_coo_tensor_unsafe_ttlo
+
+_sparse_coo_tensor_unsafe_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_unsafe_ttl = _cast3 Unmanaged._sparse_coo_tensor_unsafe_ttl
+
+_validate_sparse_coo_tensor_args_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+_validate_sparse_coo_tensor_args_ttl = _cast3 Unmanaged._validate_sparse_coo_tensor_args_ttl
+
+_validate_sparse_compressed_tensor_args_tttlL
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Layout
+  -> IO (())
+_validate_sparse_compressed_tensor_args_tttlL = _cast5 Unmanaged._validate_sparse_compressed_tensor_args_tttlL
+
+_validate_sparse_csr_tensor_args_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+_validate_sparse_csr_tensor_args_tttl = _cast4 Unmanaged._validate_sparse_csr_tensor_args_tttl
+
+_validate_sparse_csc_tensor_args_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+_validate_sparse_csc_tensor_args_tttl = _cast4 Unmanaged._validate_sparse_csc_tensor_args_tttl
+
+_validate_sparse_bsr_tensor_args_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+_validate_sparse_bsr_tensor_args_tttl = _cast4 Unmanaged._validate_sparse_bsr_tensor_args_tttl
+
+_validate_sparse_bsc_tensor_args_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (())
+_validate_sparse_bsc_tensor_args_tttl = _cast4 Unmanaged._validate_sparse_bsc_tensor_args_tttl
+
+_sparse_coo_tensor_with_dims_lllo
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_with_dims_lllo = _cast4 Unmanaged._sparse_coo_tensor_with_dims_lllo
+
+_sparse_coo_tensor_with_dims_and_tensors_llltto
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_with_dims_and_tensors_llltto = _cast6 Unmanaged._sparse_coo_tensor_with_dims_and_tensors_llltto
+
+_to_cpu_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_to_cpu_l = _cast1 Unmanaged._to_cpu_l
+
+to_dense_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+to_dense_backward_tt = _cast2 Unmanaged.to_dense_backward_tt
+
+_coalesce_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_coalesce_t = _cast1 Unmanaged._coalesce_t
+
+hspmm_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hspmm_out_ttt = _cast3 Unmanaged.hspmm_out_ttt
+
+hspmm_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hspmm_tt = _cast2 Unmanaged.hspmm_tt
+
+copy_sparse_to_sparse__ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+copy_sparse_to_sparse__ttb = _cast3 Unmanaged.copy_sparse_to_sparse__ttb
+
+copy_sparse_to_sparse__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+copy_sparse_to_sparse__tt = _cast2 Unmanaged.copy_sparse_to_sparse__tt
+
+unbind_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+unbind_tl = _cast2 Unmanaged.unbind_tl
+
+unbind_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+unbind_t = _cast1 Unmanaged.unbind_t
+
+unbind_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr TensorList)
+unbind_tn = _cast2 Unmanaged.unbind_tn
+
+mkldnn_reorder_conv2d_weight_tlllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_tlllll = _cast6 Unmanaged.mkldnn_reorder_conv2d_weight_tlllll
+
+mkldnn_reorder_conv2d_weight_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_tllll = _cast5 Unmanaged.mkldnn_reorder_conv2d_weight_tllll
+
+mkldnn_reorder_conv2d_weight_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_tlll = _cast4 Unmanaged.mkldnn_reorder_conv2d_weight_tlll
+
+mkldnn_reorder_conv2d_weight_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_tll = _cast3 Unmanaged.mkldnn_reorder_conv2d_weight_tll
+
+mkldnn_reorder_conv2d_weight_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_tl = _cast2 Unmanaged.mkldnn_reorder_conv2d_weight_tl
+
+mkldnn_reorder_conv2d_weight_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv2d_weight_t = _cast1 Unmanaged.mkldnn_reorder_conv2d_weight_t
+
+mkldnn_reorder_conv3d_weight_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_tllll = _cast5 Unmanaged.mkldnn_reorder_conv3d_weight_tllll
+
+mkldnn_reorder_conv3d_weight_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_tlll = _cast4 Unmanaged.mkldnn_reorder_conv3d_weight_tlll
+
+mkldnn_reorder_conv3d_weight_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_tll = _cast3 Unmanaged.mkldnn_reorder_conv3d_weight_tll
+
+mkldnn_reorder_conv3d_weight_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_tl = _cast2 Unmanaged.mkldnn_reorder_conv3d_weight_tl
+
+mkldnn_reorder_conv3d_weight_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_reorder_conv3d_weight_t = _cast1 Unmanaged.mkldnn_reorder_conv3d_weight_t
+
+to_mkldnn_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+to_mkldnn_backward_tt = _cast2 Unmanaged.to_mkldnn_backward_tt
+
+quantize_per_tensor_dynamic_tsb
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantize_per_tensor_dynamic_tsb = _cast3 Unmanaged.quantize_per_tensor_dynamic_tsb
+
+quantize_per_tensor_tdls
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+quantize_per_tensor_tdls = _cast4 Unmanaged.quantize_per_tensor_tdls
+
+quantize_per_tensor_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+quantize_per_tensor_ttts = _cast4 Unmanaged.quantize_per_tensor_ttts
+
+quantize_per_tensor_ltts
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr TensorList)
+quantize_per_tensor_ltts = _cast4 Unmanaged.quantize_per_tensor_ltts
+
+quantize_per_channel_tttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+quantize_per_channel_tttls = _cast5 Unmanaged.quantize_per_channel_tttls
+
+dequantize_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+dequantize_t = _cast1 Unmanaged.dequantize_t
+
+dequantize_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+dequantize_l = _cast1 Unmanaged.dequantize_l
+
+q_scale_t
+  :: ForeignPtr Tensor
+  -> IO (CDouble)
+q_scale_t = _cast1 Unmanaged.q_scale_t
+
+q_zero_point_t
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+q_zero_point_t = _cast1 Unmanaged.q_zero_point_t
+
+q_per_channel_scales_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+q_per_channel_scales_t = _cast1 Unmanaged.q_per_channel_scales_t
+
+q_per_channel_zero_points_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+q_per_channel_zero_points_t = _cast1 Unmanaged.q_per_channel_zero_points_t
+
+q_per_channel_axis_t
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+q_per_channel_axis_t = _cast1 Unmanaged.q_per_channel_axis_t
+
+int_repr_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+int_repr_t = _cast1 Unmanaged.int_repr_t
+
+_make_per_tensor_quantized_tensor_tdl
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_make_per_tensor_quantized_tensor_tdl = _cast3 Unmanaged._make_per_tensor_quantized_tensor_tdl
+
+_make_per_channel_quantized_tensor_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_make_per_channel_quantized_tensor_tttl = _cast4 Unmanaged._make_per_channel_quantized_tensor_tttl
+
+fake_quantize_per_tensor_affine_tdlll
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fake_quantize_per_tensor_affine_tdlll = _cast5 Unmanaged.fake_quantize_per_tensor_affine_tdlll
+
+fake_quantize_per_tensor_affine_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fake_quantize_per_tensor_affine_tttll = _cast5 Unmanaged.fake_quantize_per_tensor_affine_tttll
+
+fake_quantize_per_tensor_affine_cachemask_tdlll
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+fake_quantize_per_tensor_affine_cachemask_tdlll = _cast5 Unmanaged.fake_quantize_per_tensor_affine_cachemask_tdlll
+
+_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_ttttll = _cast6 Unmanaged._fake_quantize_per_tensor_affine_cachemask_tensor_qparams_ttttll
+
+fake_quantize_per_tensor_affine_cachemask_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fake_quantize_per_tensor_affine_cachemask_backward_tt = _cast2 Unmanaged.fake_quantize_per_tensor_affine_cachemask_backward_tt
+
+_fake_quantize_learnable_per_tensor_affine_tttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_fake_quantize_learnable_per_tensor_affine_tttlld = _cast6 Unmanaged._fake_quantize_learnable_per_tensor_affine_tttlld
+
+_fake_quantize_learnable_per_tensor_affine_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_fake_quantize_learnable_per_tensor_affine_tttll = _cast5 Unmanaged._fake_quantize_learnable_per_tensor_affine_tttll
+
+_fake_quantize_learnable_per_tensor_affine_backward_ttttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_fake_quantize_learnable_per_tensor_affine_backward_ttttlld = _cast7 Unmanaged._fake_quantize_learnable_per_tensor_affine_backward_ttttlld
+
+_fake_quantize_learnable_per_tensor_affine_backward_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_fake_quantize_learnable_per_tensor_affine_backward_ttttll = _cast6 Unmanaged._fake_quantize_learnable_per_tensor_affine_backward_ttttll
+
+fake_quantize_per_channel_affine_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fake_quantize_per_channel_affine_tttlll = _cast6 Unmanaged.fake_quantize_per_channel_affine_tttlll
+
+fake_quantize_per_channel_affine_cachemask_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+fake_quantize_per_channel_affine_cachemask_tttlll = _cast6 Unmanaged.fake_quantize_per_channel_affine_cachemask_tttlll
+
+fake_quantize_per_channel_affine_cachemask_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fake_quantize_per_channel_affine_cachemask_backward_tt = _cast2 Unmanaged.fake_quantize_per_channel_affine_cachemask_backward_tt
+
+_fake_quantize_learnable_per_channel_affine_tttllld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_fake_quantize_learnable_per_channel_affine_tttllld = _cast7 Unmanaged._fake_quantize_learnable_per_channel_affine_tttllld
+
+_fake_quantize_learnable_per_channel_affine_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_fake_quantize_learnable_per_channel_affine_tttlll = _cast6 Unmanaged._fake_quantize_learnable_per_channel_affine_tttlll
+
+_fake_quantize_learnable_per_channel_affine_backward_ttttllld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_fake_quantize_learnable_per_channel_affine_backward_ttttllld = _cast8 Unmanaged._fake_quantize_learnable_per_channel_affine_backward_ttttllld
+
+_fake_quantize_learnable_per_channel_affine_backward_ttttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_fake_quantize_learnable_per_channel_affine_backward_ttttlll = _cast7 Unmanaged._fake_quantize_learnable_per_channel_affine_backward_ttttlll
+
+fused_moving_avg_obs_fake_quant_tttttttdlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+fused_moving_avg_obs_fake_quant_tttttttdlllbb = _cast13 Unmanaged.fused_moving_avg_obs_fake_quant_tttttttdlllbb
+
+fused_moving_avg_obs_fake_quant_tttttttdlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+fused_moving_avg_obs_fake_quant_tttttttdlllb = _cast12 Unmanaged.fused_moving_avg_obs_fake_quant_tttttttdlllb
+
+fused_moving_avg_obs_fake_quant_tttttttdlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+fused_moving_avg_obs_fake_quant_tttttttdlll = _cast11 Unmanaged.fused_moving_avg_obs_fake_quant_tttttttdlll
+
+_fused_moving_avg_obs_fq_helper_tttttttdlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_tttttttdlllbb = _cast13 Unmanaged._fused_moving_avg_obs_fq_helper_tttttttdlllbb
+
+_fused_moving_avg_obs_fq_helper_tttttttdlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_tttttttdlllb = _cast12 Unmanaged._fused_moving_avg_obs_fq_helper_tttttttdlllb
+
+_fused_moving_avg_obs_fq_helper_tttttttdlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_tttttttdlll = _cast11 Unmanaged._fused_moving_avg_obs_fq_helper_tttttttdlll
+
+_choose_qparams_per_tensor_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(CDouble,Int64)))
+_choose_qparams_per_tensor_tb = _cast2 Unmanaged._choose_qparams_per_tensor_tb
+
+_choose_qparams_per_tensor_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(CDouble,Int64)))
+_choose_qparams_per_tensor_t = _cast1 Unmanaged._choose_qparams_per_tensor_t
+
+_saturate_weight_to_fp16_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_saturate_weight_to_fp16_t = _cast1 Unmanaged._saturate_weight_to_fp16_t
+
+choose_qparams_optimized_tlldl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+choose_qparams_optimized_tlldl = _cast5 Unmanaged.choose_qparams_optimized_tlldl
+
+_to_copy_tobM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> CBool
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_to_copy_tobM = _cast4 Unmanaged._to_copy_tobM
+
+_to_copy_tob
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_to_copy_tob = _cast3 Unmanaged._to_copy_tob
+
+_to_copy_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_to_copy_to = _cast2 Unmanaged._to_copy_to
+
+_to_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_to_copy_t = _cast1 Unmanaged._to_copy_t
+
+meshgrid_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+meshgrid_l = _cast1 Unmanaged.meshgrid_l
+
+meshgrid_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr TensorList)
+meshgrid_ls = _cast2 Unmanaged.meshgrid_ls
+
+cartesian_prod_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+cartesian_prod_l = _cast1 Unmanaged.cartesian_prod_l
+
+combinations_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+combinations_tlb = _cast3 Unmanaged.combinations_tlb
+
+combinations_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+combinations_tl = _cast2 Unmanaged.combinations_tl
+
+combinations_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+combinations_t = _cast1 Unmanaged.combinations_t
+
+result_type_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ScalarType)
+result_type_tt = _cast2 Unmanaged.result_type_tt
+
+result_type_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ScalarType)
+result_type_ts = _cast2 Unmanaged.result_type_ts
+
+result_type_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ScalarType)
+result_type_st = _cast2 Unmanaged.result_type_st
+
+result_type_ss
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ScalarType)
+result_type_ss = _cast2 Unmanaged.result_type_ss
+
+can_cast_ss
+  :: ScalarType
+  -> ScalarType
+  -> IO (CBool)
+can_cast_ss = _cast2 Unmanaged.can_cast_ss
+
+promote_types_ss
+  :: ScalarType
+  -> ScalarType
+  -> IO (ScalarType)
+promote_types_ss = _cast2 Unmanaged.promote_types_ss
+
+_local_scalar_dense_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Scalar)
+_local_scalar_dense_t = _cast1 Unmanaged._local_scalar_dense_t
+
+_lstm_mps_tllbldbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_lstm_mps_tllbldbbb = _cast9 Unmanaged._lstm_mps_tllbldbbb
+
+lstm_mps_backward_tttttttllbldbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,TensorList,TensorList)))
+lstm_mps_backward_tttttttllbldbbb = _cast15 Unmanaged.lstm_mps_backward_tttttttllbldbbb
+
+_thnn_fused_lstm_cell_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_ttttt = _cast5 Unmanaged._thnn_fused_lstm_cell_ttttt
+
+_thnn_fused_lstm_cell_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_tttt = _cast4 Unmanaged._thnn_fused_lstm_cell_tttt
+
+_thnn_fused_lstm_cell_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_ttt = _cast3 Unmanaged._thnn_fused_lstm_cell_ttt
+
+_thnn_fused_lstm_cell_backward_impl_tttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_backward_impl_tttttb = _cast6 Unmanaged._thnn_fused_lstm_cell_backward_impl_tttttb
+
+_thnn_fused_lstm_cell_backward_tttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_backward_tttttb = _cast6 Unmanaged._thnn_fused_lstm_cell_backward_tttttb
+
+_thnn_differentiable_lstm_cell_backward_tttttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_differentiable_lstm_cell_backward_tttttttt = _cast8 Unmanaged._thnn_differentiable_lstm_cell_backward_tttttttt
+
+_thnn_fused_gru_cell_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_ttttt = _cast5 Unmanaged._thnn_fused_gru_cell_ttttt
+
+_thnn_fused_gru_cell_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_tttt = _cast4 Unmanaged._thnn_fused_gru_cell_tttt
+
+_thnn_fused_gru_cell_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_ttt = _cast3 Unmanaged._thnn_fused_gru_cell_ttt
+
+_thnn_fused_gru_cell_backward_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_fused_gru_cell_backward_ttb = _cast3 Unmanaged._thnn_fused_gru_cell_backward_ttb
+
+_thnn_differentiable_gru_cell_backward_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_differentiable_gru_cell_backward_tttttt = _cast6 Unmanaged._thnn_differentiable_gru_cell_backward_tttttt
+
+lstm_tllbldbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+lstm_tllbldbbb = _cast9 Unmanaged.lstm_tllbldbbb
+
+lstm_ttllbldbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+lstm_ttllbldbb = _cast9 Unmanaged.lstm_ttllbldbb
+
+gru_ttlbldbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+gru_ttlbldbbb = _cast9 Unmanaged.gru_ttlbldbbb
+
+gru_tttlbldbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+gru_tttlbldbb = _cast9 Unmanaged.gru_tttlbldbb
+
+rnn_tanh_ttlbldbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+rnn_tanh_ttlbldbbb = _cast9 Unmanaged.rnn_tanh_ttlbldbbb
+
+rnn_tanh_tttlbldbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+rnn_tanh_tttlbldbb = _cast9 Unmanaged.rnn_tanh_tttlbldbb
+
+rnn_relu_ttlbldbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+rnn_relu_ttlbldbbb = _cast9 Unmanaged.rnn_relu_ttlbldbbb
+
+rnn_relu_tttlbldbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+rnn_relu_tttlbldbb = _cast9 Unmanaged.rnn_relu_tttlbldbb
+
+lstm_cell_tltttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+lstm_cell_tltttt = _cast6 Unmanaged.lstm_cell_tltttt
+
+lstm_cell_tlttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+lstm_cell_tlttt = _cast5 Unmanaged.lstm_cell_tlttt
+
+lstm_cell_tltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+lstm_cell_tltt = _cast4 Unmanaged.lstm_cell_tltt
+
+gru_cell_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gru_cell_tttttt = _cast6 Unmanaged.gru_cell_tttttt
+
+gru_cell_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gru_cell_ttttt = _cast5 Unmanaged.gru_cell_ttttt
+
+gru_cell_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gru_cell_tttt = _cast4 Unmanaged.gru_cell_tttt
+
+rnn_tanh_cell_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rnn_tanh_cell_tttttt = _cast6 Unmanaged.rnn_tanh_cell_tttttt
+
+rnn_tanh_cell_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rnn_tanh_cell_ttttt = _cast5 Unmanaged.rnn_tanh_cell_ttttt
+
+rnn_tanh_cell_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rnn_tanh_cell_tttt = _cast4 Unmanaged.rnn_tanh_cell_tttt
+
+rnn_relu_cell_tttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rnn_relu_cell_tttttt = _cast6 Unmanaged.rnn_relu_cell_tttttt
+
+rnn_relu_cell_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rnn_relu_cell_ttttt = _cast5 Unmanaged.rnn_relu_cell_ttttt
+
+rnn_relu_cell_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rnn_relu_cell_tttt = _cast4 Unmanaged.rnn_relu_cell_tttt
+
+quantized_lstm_cell_tlttttttttssss
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+quantized_lstm_cell_tlttttttttssss = _cast14 Unmanaged.quantized_lstm_cell_tlttttttttssss
+
+quantized_gru_cell_ttttttttttssss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+quantized_gru_cell_ttttttttttssss = _cast14 Unmanaged.quantized_gru_cell_ttttttttttssss
+
+quantized_rnn_relu_cell_ttttttttttssss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+quantized_rnn_relu_cell_ttttttttttssss = _cast14 Unmanaged.quantized_rnn_relu_cell_ttttttttttssss
+
+quantized_rnn_tanh_cell_ttttttttttssss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+quantized_rnn_tanh_cell_ttttttttttssss = _cast14 Unmanaged.quantized_rnn_tanh_cell_ttttttttttssss
+
+_pack_padded_sequence_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_pack_padded_sequence_ttb = _cast3 Unmanaged._pack_padded_sequence_ttb
+
+_pack_padded_sequence_backward_tltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_pack_padded_sequence_backward_tltb = _cast4 Unmanaged._pack_padded_sequence_backward_tltb
+
+_pad_packed_sequence_ttbsl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+_pad_packed_sequence_ttbsl = _cast5 Unmanaged._pad_packed_sequence_ttbsl
+
+lift_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lift_t = _cast1 Unmanaged.lift_t
+
+lift_fresh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lift_fresh_t = _cast1 Unmanaged.lift_fresh_t
+
+lift_fresh_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lift_fresh_copy_t = _cast1 Unmanaged.lift_fresh_copy_t
+
+masked_fill_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+masked_fill_tts = _cast3 Unmanaged.masked_fill_tts
+
+masked_fill_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+masked_fill_ttt = _cast3 Unmanaged.masked_fill_ttt
+
+masked_scatter_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+masked_scatter_ttt = _cast3 Unmanaged.masked_scatter_ttt
+
+_masked_softmax_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_ttll = _cast4 Unmanaged._masked_softmax_ttll
+
+_masked_softmax_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_ttl = _cast3 Unmanaged._masked_softmax_ttl
+
+_masked_softmax_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_tt = _cast2 Unmanaged._masked_softmax_tt
+
+_masked_softmax_backward_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_backward_tttl = _cast4 Unmanaged._masked_softmax_backward_tttl
+
+_masked_softmax_backward_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_masked_softmax_backward_ttt = _cast3 Unmanaged._masked_softmax_backward_ttt
+
+put_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+put_tttb = _cast4 Unmanaged.put_tttb
+
+put_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+put_ttt = _cast3 Unmanaged.put_ttt
+
+index_add_out_ttltts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+index_add_out_ttltts = _cast6 Unmanaged.index_add_out_ttltts
+
+index_add_out_ttltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_add_out_ttltt = _cast5 Unmanaged.index_add_out_ttltt
+
+index_add_tltts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+index_add_tltts = _cast5 Unmanaged.index_add_tltts
+
+index_add_tltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_add_tltt = _cast4 Unmanaged.index_add_tltt
+
+index_add_tntts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+index_add_tntts = _cast5 Unmanaged.index_add_tntts
+
+index_add_tntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_add_tntt = _cast4 Unmanaged.index_add_tntt
+
+index_reduce_out_ttlttsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+index_reduce_out_ttlttsb = _cast7 Unmanaged.index_reduce_out_ttlttsb
+
+index_reduce_out_ttltts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+index_reduce_out_ttltts = _cast6 Unmanaged.index_reduce_out_ttltts
+
+index_reduce_tlttsb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+index_reduce_tlttsb = _cast6 Unmanaged.index_reduce_tlttsb
+
+index_reduce_tltts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+index_reduce_tltts = _cast5 Unmanaged.index_reduce_tltts
+
+index_fill_tlts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+index_fill_tlts = _cast4 Unmanaged.index_fill_tlts
+
+index_fill_tltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_fill_tltt = _cast4 Unmanaged.index_fill_tltt
+
+index_fill_tnts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+index_fill_tnts = _cast4 Unmanaged.index_fill_tnts
+
+index_fill_tntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_fill_tntt = _cast4 Unmanaged.index_fill_tntt
+
+scatter_tltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+scatter_tltt = _cast4 Unmanaged.scatter_tltt
+
+scatter_out_ttltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+scatter_out_ttltt = _cast5 Unmanaged.scatter_out_ttltt
+
+scatter_tlts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+scatter_tlts = _cast4 Unmanaged.scatter_tlts
+
+scatter_out_ttlts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+scatter_out_ttlts = _cast5 Unmanaged.scatter_out_ttlts
+
+scatter_tltts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+scatter_tltts = _cast5 Unmanaged.scatter_tltts
+
+scatter_out_ttltts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+scatter_out_ttltts = _cast6 Unmanaged.scatter_out_ttltts
+
+scatter_tltss
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+scatter_tltss = _cast5 Unmanaged.scatter_tltss
+
+scatter_out_ttltss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+scatter_out_ttltss = _cast6 Unmanaged.scatter_out_ttltss
+
+scatter_tntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+scatter_tntt = _cast4 Unmanaged.scatter_tntt
+
+scatter_tnts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+scatter_tnts = _cast4 Unmanaged.scatter_tnts
+
+scatter_add_tltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+scatter_add_tltt = _cast4 Unmanaged.scatter_add_tltt
+
+scatter_add_out_ttltt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+scatter_add_out_ttltt = _cast5 Unmanaged.scatter_add_out_ttltt
+
+scatter_add_tntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+scatter_add_tntt = _cast4 Unmanaged.scatter_add_tntt
+
+scatter_reduce_tlttsb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+scatter_reduce_tlttsb = _cast6 Unmanaged.scatter_reduce_tlttsb
+
+scatter_reduce_tltts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+scatter_reduce_tltts = _cast5 Unmanaged.scatter_reduce_tltts
+
+scatter_reduce_out_ttlttsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+scatter_reduce_out_ttlttsb = _cast7 Unmanaged.scatter_reduce_out_ttlttsb
+
+scatter_reduce_out_ttltts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+scatter_reduce_out_ttltts = _cast6 Unmanaged.scatter_reduce_out_ttltts
+
+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_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_and_st = _cast2 Unmanaged.bitwise_and_st
+
+bitwise_and_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_and_tt = _cast2 Unmanaged.bitwise_and_tt
+
+__and___ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+__and___ts = _cast2 Unmanaged.__and___ts
+
+__and___tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> 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_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_or_st = _cast2 Unmanaged.bitwise_or_st
+
+bitwise_or_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_or_tt = _cast2 Unmanaged.bitwise_or_tt
+
+__or___ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+__or___ts = _cast2 Unmanaged.__or___ts
+
+__or___tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+__or___tt = _cast2 Unmanaged.__or___tt
+
+bitwise_xor_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_xor_out_ttt = _cast3 Unmanaged.bitwise_xor_out_ttt
+
+bitwise_xor_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_xor_out_tts = _cast3 Unmanaged.bitwise_xor_out_tts
+
+bitwise_xor_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_xor_ts = _cast2 Unmanaged.bitwise_xor_ts
+
+bitwise_xor_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_xor_st = _cast2 Unmanaged.bitwise_xor_st
+
+bitwise_xor_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_xor_tt = _cast2 Unmanaged.bitwise_xor_tt
+
+__xor___ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+__xor___ts = _cast2 Unmanaged.__xor___ts
+
+__xor___tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+__xor___tt = _cast2 Unmanaged.__xor___tt
+
+__lshift___ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+__lshift___ts = _cast2 Unmanaged.__lshift___ts
+
+__lshift___tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+__lshift___tt = _cast2 Unmanaged.__lshift___tt
+
+bitwise_left_shift_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_left_shift_tt = _cast2 Unmanaged.bitwise_left_shift_tt
+
+bitwise_left_shift_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_left_shift_out_ttt = _cast3 Unmanaged.bitwise_left_shift_out_ttt
+
+bitwise_left_shift_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_left_shift_ts = _cast2 Unmanaged.bitwise_left_shift_ts
+
+bitwise_left_shift_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_left_shift_out_tts = _cast3 Unmanaged.bitwise_left_shift_out_tts
+
+bitwise_left_shift_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_left_shift_st = _cast2 Unmanaged.bitwise_left_shift_st
+
+__rshift___ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+__rshift___ts = _cast2 Unmanaged.__rshift___ts
+
+__rshift___tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+__rshift___tt = _cast2 Unmanaged.__rshift___tt
+
+bitwise_right_shift_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_right_shift_tt = _cast2 Unmanaged.bitwise_right_shift_tt
+
+bitwise_right_shift_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_right_shift_out_ttt = _cast3 Unmanaged.bitwise_right_shift_out_ttt
+
+bitwise_right_shift_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_right_shift_ts = _cast2 Unmanaged.bitwise_right_shift_ts
+
+bitwise_right_shift_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+bitwise_right_shift_out_tts = _cast3 Unmanaged.bitwise_right_shift_out_tts
+
+bitwise_right_shift_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bitwise_right_shift_st = _cast2 Unmanaged.bitwise_right_shift_st
+
+addbmm_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addbmm_out_ttttss = _cast6 Unmanaged.addbmm_out_ttttss
+
+addbmm_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addbmm_out_tttts = _cast5 Unmanaged.addbmm_out_tttts
+
+addbmm_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addbmm_out_tttt = _cast4 Unmanaged.addbmm_out_tttt
+
+addbmm_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addbmm_tttss = _cast5 Unmanaged.addbmm_tttss
+
+addbmm_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addbmm_ttts = _cast4 Unmanaged.addbmm_ttts
+
+addbmm_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addbmm_ttt = _cast3 Unmanaged.addbmm_ttt
+
+diag_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diag_out_ttl = _cast3 Unmanaged.diag_out_ttl
+
+diag_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diag_out_tt = _cast2 Unmanaged.diag_out_tt
+
+diag_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+diag_tl = _cast2 Unmanaged.diag_tl
+
+diag_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+diag_t = _cast1 Unmanaged.diag_t
+
+cross_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cross_out_tttl = _cast4 Unmanaged.cross_out_tttl
+
+cross_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cross_out_ttt = _cast3 Unmanaged.cross_out_ttt
+
+cross_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cross_ttl = _cast3 Unmanaged.cross_ttl
+
+cross_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cross_tt = _cast2 Unmanaged.cross_tt
+
+triu_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triu_out_ttl = _cast3 Unmanaged.triu_out_ttl
+
+triu_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+triu_out_tt = _cast2 Unmanaged.triu_out_tt
+
+triu_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triu_tl = _cast2 Unmanaged.triu_tl
+
+triu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+triu_t = _cast1 Unmanaged.triu_t
+
+tril_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tril_out_ttl = _cast3 Unmanaged.tril_out_ttl
+
+tril_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tril_out_tt = _cast2 Unmanaged.tril_out_tt
+
+tril_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tril_tl = _cast2 Unmanaged.tril_tl
+
+tril_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tril_t = _cast1 Unmanaged.tril_t
+
+tril_indices_lllo
+  :: Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+tril_indices_lllo = _cast4 Unmanaged.tril_indices_lllo
+
+tril_indices_lll
+  :: Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tril_indices_lll = _cast3 Unmanaged.tril_indices_lll
+
+tril_indices_ll
+  :: Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tril_indices_ll = _cast2 Unmanaged.tril_indices_ll
+
diff --git a/src/Torch/Internal/Managed/Native/Native7.hs b/src/Torch/Internal/Managed/Native/Native7.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native7.hs
@@ -0,0 +1,2040 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native7 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native7 as Unmanaged
+
+
+triu_indices_lllo
+  :: Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+triu_indices_lllo = _cast4 Unmanaged.triu_indices_lllo
+
+triu_indices_lll
+  :: Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triu_indices_lll = _cast3 Unmanaged.triu_indices_lll
+
+triu_indices_ll
+  :: Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triu_indices_ll = _cast2 Unmanaged.triu_indices_ll
+
+trace_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+trace_t = _cast1 Unmanaged.trace_t
+
+trace_backward_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+trace_backward_tl = _cast2 Unmanaged.trace_backward_tl
+
+ne_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+ne_out_tts = _cast3 Unmanaged.ne_out_tts
+
+ne_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+ne_ts = _cast2 Unmanaged.ne_ts
+
+ne_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ne_out_ttt = _cast3 Unmanaged.ne_out_ttt
+
+ne_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ne_tt = _cast2 Unmanaged.ne_tt
+
+not_equal_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+not_equal_out_tts = _cast3 Unmanaged.not_equal_out_tts
+
+not_equal_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+not_equal_ts = _cast2 Unmanaged.not_equal_ts
+
+not_equal_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+not_equal_out_ttt = _cast3 Unmanaged.not_equal_out_ttt
+
+not_equal_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+not_equal_tt = _cast2 Unmanaged.not_equal_tt
+
+eq_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+eq_out_tts = _cast3 Unmanaged.eq_out_tts
+
+eq_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+eq_ts = _cast2 Unmanaged.eq_ts
+
+eq_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+eq_out_ttt = _cast3 Unmanaged.eq_out_ttt
+
+eq_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+eq_tt = _cast2 Unmanaged.eq_tt
+
+ge_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+ge_out_tts = _cast3 Unmanaged.ge_out_tts
+
+ge_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+ge_ts = _cast2 Unmanaged.ge_ts
+
+ge_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ge_out_ttt = _cast3 Unmanaged.ge_out_ttt
+
+ge_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ge_tt = _cast2 Unmanaged.ge_tt
+
+greater_equal_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+greater_equal_out_tts = _cast3 Unmanaged.greater_equal_out_tts
+
+greater_equal_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+greater_equal_ts = _cast2 Unmanaged.greater_equal_ts
+
+greater_equal_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+greater_equal_out_ttt = _cast3 Unmanaged.greater_equal_out_ttt
+
+greater_equal_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+greater_equal_tt = _cast2 Unmanaged.greater_equal_tt
+
+le_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+le_out_tts = _cast3 Unmanaged.le_out_tts
+
+le_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+le_ts = _cast2 Unmanaged.le_ts
+
+le_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+le_out_ttt = _cast3 Unmanaged.le_out_ttt
+
+le_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+le_tt = _cast2 Unmanaged.le_tt
+
+less_equal_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+less_equal_out_tts = _cast3 Unmanaged.less_equal_out_tts
+
+less_equal_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+less_equal_ts = _cast2 Unmanaged.less_equal_ts
+
+less_equal_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+less_equal_out_ttt = _cast3 Unmanaged.less_equal_out_ttt
+
+less_equal_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+less_equal_tt = _cast2 Unmanaged.less_equal_tt
+
+gt_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+gt_out_tts = _cast3 Unmanaged.gt_out_tts
+
+gt_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+gt_ts = _cast2 Unmanaged.gt_ts
+
+gt_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gt_out_ttt = _cast3 Unmanaged.gt_out_ttt
+
+gt_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gt_tt = _cast2 Unmanaged.gt_tt
+
+greater_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+greater_out_tts = _cast3 Unmanaged.greater_out_tts
+
+greater_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+greater_ts = _cast2 Unmanaged.greater_ts
+
+greater_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+greater_out_ttt = _cast3 Unmanaged.greater_out_ttt
+
+greater_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+greater_tt = _cast2 Unmanaged.greater_tt
+
+lt_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+lt_out_tts = _cast3 Unmanaged.lt_out_tts
+
+lt_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+lt_ts = _cast2 Unmanaged.lt_ts
+
+lt_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lt_out_ttt = _cast3 Unmanaged.lt_out_ttt
+
+lt_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lt_tt = _cast2 Unmanaged.lt_tt
+
+less_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+less_out_tts = _cast3 Unmanaged.less_out_tts
+
+less_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+less_ts = _cast2 Unmanaged.less_ts
+
+less_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+less_out_ttt = _cast3 Unmanaged.less_out_ttt
+
+less_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+less_tt = _cast2 Unmanaged.less_tt
+
+take_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+take_out_ttt = _cast3 Unmanaged.take_out_ttt
+
+take_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+take_tt = _cast2 Unmanaged.take_tt
+
+take_along_dim_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+take_along_dim_out_tttl = _cast4 Unmanaged.take_along_dim_out_tttl
+
+take_along_dim_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+take_along_dim_out_ttt = _cast3 Unmanaged.take_along_dim_out_ttt
+
+take_along_dim_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+take_along_dim_ttl = _cast3 Unmanaged.take_along_dim_ttl
+
+take_along_dim_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+take_along_dim_tt = _cast2 Unmanaged.take_along_dim_tt
+
+index_select_out_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_select_out_ttlt = _cast4 Unmanaged.index_select_out_ttlt
+
+index_select_tlt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_select_tlt = _cast3 Unmanaged.index_select_tlt
+
+index_select_out_ttnt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_select_out_ttnt = _cast4 Unmanaged.index_select_out_ttnt
+
+index_select_tnt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_select_tnt = _cast3 Unmanaged.index_select_tnt
+
+index_select_backward_tllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+index_select_backward_tllt = _cast4 Unmanaged.index_select_backward_tllt
+
+masked_select_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+masked_select_out_ttt = _cast3 Unmanaged.masked_select_out_ttt
+
+masked_select_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+masked_select_tt = _cast2 Unmanaged.masked_select_tt
+
+masked_select_backward_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+masked_select_backward_ttt = _cast3 Unmanaged.masked_select_backward_ttt
+
+nonzero_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nonzero_out_tt = _cast2 Unmanaged.nonzero_out_tt
+
+nonzero_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nonzero_t = _cast1 Unmanaged.nonzero_t
+
+nonzero_numpy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+nonzero_numpy_t = _cast1 Unmanaged.nonzero_numpy_t
+
+argwhere_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+argwhere_t = _cast1 Unmanaged.argwhere_t
+
+gather_out_ttltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+gather_out_ttltb = _cast5 Unmanaged.gather_out_ttltb
+
+gather_out_ttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gather_out_ttlt = _cast4 Unmanaged.gather_out_ttlt
+
+gather_tltb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+gather_tltb = _cast4 Unmanaged.gather_tltb
+
+gather_tlt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gather_tlt = _cast3 Unmanaged.gather_tlt
+
+gather_backward_ttltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+gather_backward_ttltb = _cast5 Unmanaged.gather_backward_ttltb
+
+gather_out_ttntb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+gather_out_ttntb = _cast5 Unmanaged.gather_out_ttntb
+
+gather_out_ttnt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gather_out_ttnt = _cast4 Unmanaged.gather_out_ttnt
+
+gather_tntb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+gather_tntb = _cast4 Unmanaged.gather_tntb
+
+gather_tnt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+gather_tnt = _cast3 Unmanaged.gather_tnt
+
+_gather_sparse_backward_tltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_gather_sparse_backward_tltt = _cast4 Unmanaged._gather_sparse_backward_tltt
+
+addcmul_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addcmul_out_tttts = _cast5 Unmanaged.addcmul_out_tttts
+
+addcmul_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addcmul_out_tttt = _cast4 Unmanaged.addcmul_out_tttt
+
+addcmul_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addcmul_ttts = _cast4 Unmanaged.addcmul_ttts
+
+addcmul_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addcmul_ttt = _cast3 Unmanaged.addcmul_ttt
+
+addcdiv_out_tttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addcdiv_out_tttts = _cast5 Unmanaged.addcdiv_out_tttts
+
+addcdiv_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addcdiv_out_tttt = _cast4 Unmanaged.addcdiv_out_tttt
+
+addcdiv_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+addcdiv_ttts = _cast4 Unmanaged.addcdiv_ttts
+
+addcdiv_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+addcdiv_ttt = _cast3 Unmanaged.addcdiv_ttt
+
+cross_entropy_loss_tttlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+cross_entropy_loss_tttlld = _cast6 Unmanaged.cross_entropy_loss_tttlld
+
+cross_entropy_loss_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cross_entropy_loss_tttll = _cast5 Unmanaged.cross_entropy_loss_tttll
+
+cross_entropy_loss_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+cross_entropy_loss_tttl = _cast4 Unmanaged.cross_entropy_loss_tttl
+
+cross_entropy_loss_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cross_entropy_loss_ttt = _cast3 Unmanaged.cross_entropy_loss_ttt
+
+cross_entropy_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cross_entropy_loss_tt = _cast2 Unmanaged.cross_entropy_loss_tt
+
+triangular_solve_out_ttttbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+triangular_solve_out_ttttbbb = _cast7 Unmanaged.triangular_solve_out_ttttbbb
+
+triangular_solve_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+triangular_solve_out_ttttbb = _cast6 Unmanaged.triangular_solve_out_ttttbb
+
+triangular_solve_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+triangular_solve_out_ttttb = _cast5 Unmanaged.triangular_solve_out_ttttb
+
+triangular_solve_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+triangular_solve_out_tttt = _cast4 Unmanaged.triangular_solve_out_tttt
+
+triangular_solve_ttbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+triangular_solve_ttbbb = _cast5 Unmanaged.triangular_solve_ttbbb
+
+triangular_solve_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+triangular_solve_ttbb = _cast4 Unmanaged.triangular_solve_ttbb
+
+triangular_solve_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+triangular_solve_ttb = _cast3 Unmanaged.triangular_solve_ttb
+
+triangular_solve_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+triangular_solve_tt = _cast2 Unmanaged.triangular_solve_tt
+
+_linalg_check_errors_tsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (())
+_linalg_check_errors_tsb = _cast3 Unmanaged._linalg_check_errors_tsb
+
+linalg_solve_triangular_out_tttbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_solve_triangular_out_tttbbb = _cast6 Unmanaged.linalg_solve_triangular_out_tttbbb
+
+linalg_solve_triangular_out_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_solve_triangular_out_tttbb = _cast5 Unmanaged.linalg_solve_triangular_out_tttbb
+
+linalg_solve_triangular_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_solve_triangular_out_tttb = _cast4 Unmanaged.linalg_solve_triangular_out_tttb
+
+linalg_solve_triangular_ttbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_solve_triangular_ttbbb = _cast5 Unmanaged.linalg_solve_triangular_ttbbb
+
+linalg_solve_triangular_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_solve_triangular_ttbb = _cast4 Unmanaged.linalg_solve_triangular_ttbb
+
+linalg_solve_triangular_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+linalg_solve_triangular_ttb = _cast3 Unmanaged.linalg_solve_triangular_ttb
+
+linalg_vander_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linalg_vander_tl = _cast2 Unmanaged.linalg_vander_tl
+
+linalg_vander_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+linalg_vander_t = _cast1 Unmanaged.linalg_vander_t
+
+svd_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_out_ttttbb = _cast6 Unmanaged.svd_out_ttttbb
+
+svd_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_out_ttttb = _cast5 Unmanaged.svd_out_ttttb
+
+svd_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_out_tttt = _cast4 Unmanaged.svd_out_tttt
+
+svd_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_tbb = _cast3 Unmanaged.svd_tbb
+
+svd_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_tb = _cast2 Unmanaged.svd_tb
+
+svd_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_t = _cast1 Unmanaged.svd_t
+
+swapaxes_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+swapaxes_tll = _cast3 Unmanaged.swapaxes_tll
+
+swapdims_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+swapdims_tll = _cast3 Unmanaged.swapdims_tll
+
+cholesky_out_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cholesky_out_ttb = _cast3 Unmanaged.cholesky_out_ttb
+
+cholesky_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cholesky_out_tt = _cast2 Unmanaged.cholesky_out_tt
+
+cholesky_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cholesky_tb = _cast2 Unmanaged.cholesky_tb
+
+cholesky_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cholesky_t = _cast1 Unmanaged.cholesky_t
+
+cholesky_solve_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cholesky_solve_out_tttb = _cast4 Unmanaged.cholesky_solve_out_tttb
+
+cholesky_solve_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cholesky_solve_out_ttt = _cast3 Unmanaged.cholesky_solve_out_ttt
+
+cholesky_solve_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cholesky_solve_ttb = _cast3 Unmanaged.cholesky_solve_ttb
+
+cholesky_solve_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cholesky_solve_tt = _cast2 Unmanaged.cholesky_solve_tt
+
+_cholesky_solve_helper_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_cholesky_solve_helper_ttb = _cast3 Unmanaged._cholesky_solve_helper_ttb
+
+cholesky_inverse_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cholesky_inverse_tb = _cast2 Unmanaged.cholesky_inverse_tb
+
+cholesky_inverse_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cholesky_inverse_t = _cast1 Unmanaged.cholesky_inverse_t
+
+cholesky_inverse_out_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+cholesky_inverse_out_ttb = _cast3 Unmanaged.cholesky_inverse_out_ttb
+
+cholesky_inverse_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+cholesky_inverse_out_tt = _cast2 Unmanaged.cholesky_inverse_out_tt
+
+qr_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+qr_out_tttb = _cast4 Unmanaged.qr_out_tttb
+
+qr_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+qr_out_ttt = _cast3 Unmanaged.qr_out_ttt
+
+qr_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+qr_tb = _cast2 Unmanaged.qr_tb
+
+qr_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+qr_t = _cast1 Unmanaged.qr_t
+
+geqrf_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+geqrf_out_ttt = _cast3 Unmanaged.geqrf_out_ttt
+
+geqrf_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+geqrf_t = _cast1 Unmanaged.geqrf_t
+
+orgqr_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+orgqr_tt = _cast2 Unmanaged.orgqr_tt
+
+orgqr_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+orgqr_out_ttt = _cast3 Unmanaged.orgqr_out_ttt
+
+ormqr_out_ttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+ormqr_out_ttttbb = _cast6 Unmanaged.ormqr_out_ttttbb
+
+ormqr_out_ttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+ormqr_out_ttttb = _cast5 Unmanaged.ormqr_out_ttttb
+
+ormqr_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ormqr_out_tttt = _cast4 Unmanaged.ormqr_out_tttt
+
+ormqr_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+ormqr_tttbb = _cast5 Unmanaged.ormqr_tttbb
+
+ormqr_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+ormqr_tttb = _cast4 Unmanaged.ormqr_tttb
+
+ormqr_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+ormqr_ttt = _cast3 Unmanaged.ormqr_ttt
+
+_lu_with_info_tbb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_lu_with_info_tbb = _cast3 Unmanaged._lu_with_info_tbb
+
+_lu_with_info_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_lu_with_info_tb = _cast2 Unmanaged._lu_with_info_tb
+
+_lu_with_info_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+_lu_with_info_t = _cast1 Unmanaged._lu_with_info_t
+
+lu_solve_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lu_solve_out_tttt = _cast4 Unmanaged.lu_solve_out_tttt
+
+lu_solve_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lu_solve_ttt = _cast3 Unmanaged.lu_solve_ttt
+
+lu_unpack_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_ttbb = _cast4 Unmanaged.lu_unpack_ttbb
+
+lu_unpack_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_ttb = _cast3 Unmanaged.lu_unpack_ttb
+
+lu_unpack_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_tt = _cast2 Unmanaged.lu_unpack_tt
+
+lu_unpack_out_tttttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_out_tttttbb = _cast7 Unmanaged.lu_unpack_out_tttttbb
+
+lu_unpack_out_tttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_out_tttttb = _cast6 Unmanaged.lu_unpack_out_tttttb
+
+lu_unpack_out_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_out_ttttt = _cast5 Unmanaged.lu_unpack_out_ttttt
+
+multinomial_out_ttlbG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+multinomial_out_ttlbG = _cast5 Unmanaged.multinomial_out_ttlbG
+
+multinomial_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+multinomial_out_ttlb = _cast4 Unmanaged.multinomial_out_ttlb
+
+multinomial_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+multinomial_out_ttl = _cast3 Unmanaged.multinomial_out_ttl
+
+multinomial_tlbG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+multinomial_tlbG = _cast4 Unmanaged.multinomial_tlbG
+
+multinomial_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+multinomial_tlb = _cast3 Unmanaged.multinomial_tlb
+
+multinomial_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+multinomial_tl = _cast2 Unmanaged.multinomial_tl
+
+lgamma_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lgamma_out_tt = _cast2 Unmanaged.lgamma_out_tt
+
+lgamma_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lgamma_t = _cast1 Unmanaged.lgamma_t
+
+digamma_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+digamma_out_tt = _cast2 Unmanaged.digamma_out_tt
+
+digamma_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+digamma_t = _cast1 Unmanaged.digamma_t
+
+polygamma_out_tlt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+polygamma_out_tlt = _cast3 Unmanaged.polygamma_out_tlt
+
+polygamma_lt
+  :: Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+polygamma_lt = _cast2 Unmanaged.polygamma_lt
+
+erfinv_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+erfinv_t = _cast1 Unmanaged.erfinv_t
+
+erfinv_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+erfinv_out_tt = _cast2 Unmanaged.erfinv_out_tt
+
+i0_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+i0_t = _cast1 Unmanaged.i0_t
+
+i0__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+i0__t = _cast1 Unmanaged.i0__t
+
+i0_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+i0_out_tt = _cast2 Unmanaged.i0_out_tt
+
+sign_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sign_t = _cast1 Unmanaged.sign_t
+
+sign_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sign_out_tt = _cast2 Unmanaged.sign_out_tt
+
+signbit_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+signbit_t = _cast1 Unmanaged.signbit_t
+
+signbit_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+signbit_out_tt = _cast2 Unmanaged.signbit_out_tt
+
+dist_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+dist_tts = _cast3 Unmanaged.dist_tts
+
+dist_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+dist_tt = _cast2 Unmanaged.dist_tt
+
+atan2_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atan2_out_ttt = _cast3 Unmanaged.atan2_out_ttt
+
+atan2_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+atan2_tt = _cast2 Unmanaged.atan2_tt
+
+arctan2_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arctan2_tt = _cast2 Unmanaged.arctan2_tt
+
+arctan2_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+arctan2_out_ttt = _cast3 Unmanaged.arctan2_out_ttt
+
+lerp_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+lerp_out_ttts = _cast4 Unmanaged.lerp_out_ttts
+
+lerp_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lerp_out_tttt = _cast4 Unmanaged.lerp_out_tttt
+
+lerp_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+lerp_tts = _cast3 Unmanaged.lerp_tts
+
+lerp_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+lerp_ttt = _cast3 Unmanaged.lerp_ttt
+
+histc_out_ttlss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+histc_out_ttlss = _cast5 Unmanaged.histc_out_ttlss
+
+histc_out_ttls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+histc_out_ttls = _cast4 Unmanaged.histc_out_ttls
+
+histc_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+histc_out_ttl = _cast3 Unmanaged.histc_out_ttl
+
+histc_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+histc_out_tt = _cast2 Unmanaged.histc_out_tt
+
+histc_tlss
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+histc_tlss = _cast4 Unmanaged.histc_tlss
+
+histc_tls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+histc_tls = _cast3 Unmanaged.histc_tls
+
+histc_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+histc_tl = _cast2 Unmanaged.histc_tl
+
+histc_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+histc_t = _cast1 Unmanaged.histc_t
+
+histogram_out_tttttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttttb = _cast6 Unmanaged.histogram_out_tttttb
+
+histogram_out_ttttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_out_ttttt = _cast5 Unmanaged.histogram_out_ttttt
+
+histogram_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttt = _cast4 Unmanaged.histogram_out_tttt
+
+histogram_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_tttb = _cast4 Unmanaged.histogram_tttb
+
+histogram_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_ttt = _cast3 Unmanaged.histogram_ttt
+
+histogram_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_tt = _cast2 Unmanaged.histogram_tt
+
+histogram_out_tttlatb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttlatb = _cast7 Unmanaged.histogram_out_tttlatb
+
+histogram_out_tttlat
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttlat = _cast6 Unmanaged.histogram_out_tttlat
+
+histogram_out_tttla
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttla = _cast5 Unmanaged.histogram_out_tttla
+
+histogram_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttl = _cast4 Unmanaged.histogram_out_tttl
+
+histogram_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_out_ttt = _cast3 Unmanaged.histogram_out_ttt
+
+histogram_tlatb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_tlatb = _cast5 Unmanaged.histogram_tlatb
+
+histogram_tlat
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_tlat = _cast4 Unmanaged.histogram_tlat
+
+histogram_tla
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_tla = _cast3 Unmanaged.histogram_tla
+
+histogram_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_tl = _cast2 Unmanaged.histogram_tl
+
+histogram_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+histogram_t = _cast1 Unmanaged.histogram_t
+
+_histogramdd_bin_edges_tlatb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr TensorList)
+_histogramdd_bin_edges_tlatb = _cast5 Unmanaged._histogramdd_bin_edges_tlatb
+
+_histogramdd_bin_edges_tlat
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+_histogramdd_bin_edges_tlat = _cast4 Unmanaged._histogramdd_bin_edges_tlat
+
+_histogramdd_bin_edges_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr TensorList)
+_histogramdd_bin_edges_tla = _cast3 Unmanaged._histogramdd_bin_edges_tla
+
+_histogramdd_bin_edges_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr TensorList)
+_histogramdd_bin_edges_tl = _cast2 Unmanaged._histogramdd_bin_edges_tl
+
+_histogramdd_from_bin_cts_tlatb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_cts_tlatb = _cast5 Unmanaged._histogramdd_from_bin_cts_tlatb
+
+_histogramdd_from_bin_cts_tlat
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_cts_tlat = _cast4 Unmanaged._histogramdd_from_bin_cts_tlat
+
+_histogramdd_from_bin_cts_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_cts_tla = _cast3 Unmanaged._histogramdd_from_bin_cts_tla
+
+_histogramdd_from_bin_cts_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_cts_tl = _cast2 Unmanaged._histogramdd_from_bin_cts_tl
+
+_histogramdd_from_bin_tensors_tltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_tensors_tltb = _cast4 Unmanaged._histogramdd_from_bin_tensors_tltb
+
+_histogramdd_from_bin_tensors_tlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_tensors_tlt = _cast3 Unmanaged._histogramdd_from_bin_tensors_tlt
+
+_histogramdd_from_bin_tensors_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Tensor)
+_histogramdd_from_bin_tensors_tl = _cast2 Unmanaged._histogramdd_from_bin_tensors_tl
+
+histogramdd_tlatb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,TensorList)))
+histogramdd_tlatb = _cast5 Unmanaged.histogramdd_tlatb
+
+histogramdd_tlat
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,TensorList)))
+histogramdd_tlat = _cast4 Unmanaged.histogramdd_tlat
+
+histogramdd_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr (StdTuple '(Tensor,TensorList)))
+histogramdd_tla = _cast3 Unmanaged.histogramdd_tla
+
+histogramdd_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,TensorList)))
+histogramdd_tl = _cast2 Unmanaged.histogramdd_tl
+
+fmod_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+fmod_out_tts = _cast3 Unmanaged.fmod_out_tts
+
+fmod_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+fmod_ts = _cast2 Unmanaged.fmod_ts
+
+fmod_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fmod_out_ttt = _cast3 Unmanaged.fmod_out_ttt
+
+fmod_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fmod_tt = _cast2 Unmanaged.fmod_tt
+
+hypot_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hypot_out_ttt = _cast3 Unmanaged.hypot_out_ttt
+
+hypot_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hypot_tt = _cast2 Unmanaged.hypot_tt
+
+igamma_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+igamma_out_ttt = _cast3 Unmanaged.igamma_out_ttt
+
+igamma_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+igamma_tt = _cast2 Unmanaged.igamma_tt
+
+igammac_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+igammac_out_ttt = _cast3 Unmanaged.igammac_out_ttt
+
+igammac_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+igammac_tt = _cast2 Unmanaged.igammac_tt
+
+nextafter_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nextafter_out_ttt = _cast3 Unmanaged.nextafter_out_ttt
+
+nextafter_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nextafter_tt = _cast2 Unmanaged.nextafter_tt
+
+remainder_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+remainder_out_tts = _cast3 Unmanaged.remainder_out_tts
+
+remainder_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+remainder_ts = _cast2 Unmanaged.remainder_ts
+
+remainder_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+remainder_out_ttt = _cast3 Unmanaged.remainder_out_ttt
+
+remainder_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+remainder_tt = _cast2 Unmanaged.remainder_tt
+
+remainder_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+remainder_st = _cast2 Unmanaged.remainder_st
+
+min_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+min_t = _cast1 Unmanaged.min_t
+
+fmin_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fmin_tt = _cast2 Unmanaged.fmin_tt
+
+fmin_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fmin_out_ttt = _cast3 Unmanaged.fmin_out_ttt
+
+max_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+max_t = _cast1 Unmanaged.max_t
+
+fmax_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fmax_tt = _cast2 Unmanaged.fmax_tt
+
+fmax_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fmax_out_ttt = _cast3 Unmanaged.fmax_out_ttt
+
+maximum_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+maximum_tt = _cast2 Unmanaged.maximum_tt
+
+maximum_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+maximum_out_ttt = _cast3 Unmanaged.maximum_out_ttt
+
+max_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+max_tt = _cast2 Unmanaged.max_tt
+
+max_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+max_out_ttt = _cast3 Unmanaged.max_out_ttt
+
+max_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+max_out_tt = _cast2 Unmanaged.max_out_tt
+
+minimum_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+minimum_tt = _cast2 Unmanaged.minimum_tt
+
+minimum_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+minimum_out_ttt = _cast3 Unmanaged.minimum_out_ttt
+
+min_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+min_out_ttt = _cast3 Unmanaged.min_out_ttt
+
+min_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+min_tt = _cast2 Unmanaged.min_tt
+
+quantile_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+quantile_ttlbs = _cast5 Unmanaged.quantile_ttlbs
+
+quantile_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantile_ttlb = _cast4 Unmanaged.quantile_ttlb
+
+quantile_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+quantile_ttl = _cast3 Unmanaged.quantile_ttl
+
+quantile_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+quantile_tt = _cast2 Unmanaged.quantile_tt
+
+quantile_out_tttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+quantile_out_tttlbs = _cast6 Unmanaged.quantile_out_tttlbs
+
+quantile_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantile_out_tttlb = _cast5 Unmanaged.quantile_out_tttlb
+
+quantile_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+quantile_out_tttl = _cast4 Unmanaged.quantile_out_tttl
+
+quantile_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+quantile_out_ttt = _cast3 Unmanaged.quantile_out_ttt
+
+quantile_tdlbs
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+quantile_tdlbs = _cast5 Unmanaged.quantile_tdlbs
+
+quantile_tdlb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantile_tdlb = _cast4 Unmanaged.quantile_tdlb
+
+quantile_tdl
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+quantile_tdl = _cast3 Unmanaged.quantile_tdl
+
+quantile_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+quantile_td = _cast2 Unmanaged.quantile_td
+
+quantile_out_ttdlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+quantile_out_ttdlbs = _cast6 Unmanaged.quantile_out_ttdlbs
+
+quantile_out_ttdlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+quantile_out_ttdlb = _cast5 Unmanaged.quantile_out_ttdlb
+
+quantile_out_ttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+quantile_out_ttdl = _cast4 Unmanaged.quantile_out_ttdl
+
+quantile_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+quantile_out_ttd = _cast3 Unmanaged.quantile_out_ttd
+
+nanquantile_ttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+nanquantile_ttlbs = _cast5 Unmanaged.nanquantile_ttlbs
+
+nanquantile_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nanquantile_ttlb = _cast4 Unmanaged.nanquantile_ttlb
+
+nanquantile_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nanquantile_ttl = _cast3 Unmanaged.nanquantile_ttl
+
+nanquantile_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nanquantile_tt = _cast2 Unmanaged.nanquantile_tt
+
+nanquantile_out_tttlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+nanquantile_out_tttlbs = _cast6 Unmanaged.nanquantile_out_tttlbs
+
+nanquantile_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nanquantile_out_tttlb = _cast5 Unmanaged.nanquantile_out_tttlb
+
+nanquantile_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nanquantile_out_tttl = _cast4 Unmanaged.nanquantile_out_tttl
+
+nanquantile_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nanquantile_out_ttt = _cast3 Unmanaged.nanquantile_out_ttt
+
+nanquantile_tdlbs
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+nanquantile_tdlbs = _cast5 Unmanaged.nanquantile_tdlbs
+
+nanquantile_tdlb
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nanquantile_tdlb = _cast4 Unmanaged.nanquantile_tdlb
+
+nanquantile_tdl
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nanquantile_tdl = _cast3 Unmanaged.nanquantile_tdl
+
+nanquantile_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nanquantile_td = _cast2 Unmanaged.nanquantile_td
+
+nanquantile_out_ttdlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+nanquantile_out_ttdlbs = _cast6 Unmanaged.nanquantile_out_ttdlbs
+
diff --git a/src/Torch/Internal/Managed/Native/Native8.hs b/src/Torch/Internal/Managed/Native/Native8.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native8.hs
@@ -0,0 +1,2000 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native8 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native8 as Unmanaged
+
+
+nanquantile_out_ttdlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+nanquantile_out_ttdlb = _cast5 Unmanaged.nanquantile_out_ttdlb
+
+nanquantile_out_ttdl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nanquantile_out_ttdl = _cast4 Unmanaged.nanquantile_out_ttdl
+
+nanquantile_out_ttd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+nanquantile_out_ttd = _cast3 Unmanaged.nanquantile_out_ttd
+
+sort_out_tttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_tttlb = _cast5 Unmanaged.sort_out_tttlb
+
+sort_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_tttl = _cast4 Unmanaged.sort_out_tttl
+
+sort_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_ttt = _cast3 Unmanaged.sort_out_ttt
+
+sort_out_tttblb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_tttblb = _cast6 Unmanaged.sort_out_tttblb
+
+sort_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_tttb = _cast4 Unmanaged.sort_out_tttb
+
+sort_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_tlb = _cast3 Unmanaged.sort_tlb
+
+sort_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_tl = _cast2 Unmanaged.sort_tl
+
+sort_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_t = _cast1 Unmanaged.sort_t
+
+sort_tblb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_tblb = _cast4 Unmanaged.sort_tblb
+
+-- sort_tbl
+--   :: ForeignPtr Tensor
+--   -> CBool
+--   -> Int64
+--   -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+-- sort_tbl = _cast3 Unmanaged.sort_tbl
+
+sort_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_tb = _cast2 Unmanaged.sort_tb
+
+sort_out_tttnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_tttnb = _cast5 Unmanaged.sort_out_tttnb
+
+sort_out_tttn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_tttn = _cast4 Unmanaged.sort_out_tttn
+
+sort_out_tttbnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_tttbnb = _cast6 Unmanaged.sort_out_tttbnb
+
+sort_out_tttbn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_out_tttbn = _cast5 Unmanaged.sort_out_tttbn
+
+sort_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_tnb = _cast3 Unmanaged.sort_tnb
+
+sort_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_tn = _cast2 Unmanaged.sort_tn
+
+sort_tbnb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_tbnb = _cast4 Unmanaged.sort_tbnb
+
+sort_tbn
+  :: ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+sort_tbn = _cast3 Unmanaged.sort_tbn
+
+msort_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+msort_out_tt = _cast2 Unmanaged.msort_out_tt
+
+msort_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+msort_t = _cast1 Unmanaged.msort_t
+
+argsort_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argsort_tlb = _cast3 Unmanaged.argsort_tlb
+
+argsort_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+argsort_tl = _cast2 Unmanaged.argsort_tl
+
+argsort_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+argsort_t = _cast1 Unmanaged.argsort_t
+
+argsort_tblb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argsort_tblb = _cast4 Unmanaged.argsort_tblb
+
+argsort_tbl
+  :: ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+argsort_tbl = _cast3 Unmanaged.argsort_tbl
+
+argsort_tb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argsort_tb = _cast2 Unmanaged.argsort_tb
+
+argsort_tnb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+argsort_tnb = _cast3 Unmanaged.argsort_tnb
+
+argsort_tn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+argsort_tn = _cast2 Unmanaged.argsort_tn
+
+topk_out_tttllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+topk_out_tttllbb = _cast7 Unmanaged.topk_out_tttllbb
+
+topk_out_tttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+topk_out_tttllb = _cast6 Unmanaged.topk_out_tttllb
+
+topk_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+topk_out_tttll = _cast5 Unmanaged.topk_out_tttll
+
+topk_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+topk_out_tttl = _cast4 Unmanaged.topk_out_tttl
+
+topk_tllbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+topk_tllbb = _cast5 Unmanaged.topk_tllbb
+
+topk_tllb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+topk_tllb = _cast4 Unmanaged.topk_tllb
+
+topk_tll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+topk_tll = _cast3 Unmanaged.topk_tll
+
+topk_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+topk_tl = _cast2 Unmanaged.topk_tl
+
+all_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+all_t = _cast1 Unmanaged.all_t
+
+all_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+all_out_tt = _cast2 Unmanaged.all_out_tt
+
+any_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+any_t = _cast1 Unmanaged.any_t
+
+any_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+any_out_tt = _cast2 Unmanaged.any_out_tt
+
+renorm_out_ttsls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> Int64
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+renorm_out_ttsls = _cast5 Unmanaged.renorm_out_ttsls
+
+renorm_tsls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> Int64
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+renorm_tsls = _cast4 Unmanaged.renorm_tsls
+
+unfold_backward_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+unfold_backward_tllll = _cast5 Unmanaged.unfold_backward_tllll
+
+equal_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+equal_tt = _cast2 Unmanaged.equal_tt
+
+pow_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+pow_out_ttt = _cast3 Unmanaged.pow_out_ttt
+
+pow_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+pow_tt = _cast2 Unmanaged.pow_tt
+
+pow_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+pow_out_tst = _cast3 Unmanaged.pow_out_tst
+
+pow_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+pow_st = _cast2 Unmanaged.pow_st
+
+pow_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+pow_out_tts = _cast3 Unmanaged.pow_out_tts
+
+pow_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+pow_ts = _cast2 Unmanaged.pow_ts
+
+float_power_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+float_power_out_ttt = _cast3 Unmanaged.float_power_out_ttt
+
+float_power_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+float_power_tt = _cast2 Unmanaged.float_power_tt
+
+float_power_out_tst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+float_power_out_tst = _cast3 Unmanaged.float_power_out_tst
+
+float_power_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+float_power_st = _cast2 Unmanaged.float_power_st
+
+float_power_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+float_power_out_tts = _cast3 Unmanaged.float_power_out_tts
+
+float_power_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+float_power_ts = _cast2 Unmanaged.float_power_ts
+
+normal_functional_tddG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_functional_tddG = _cast4 Unmanaged.normal_functional_tddG
+
+normal_functional_tdd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+normal_functional_tdd = _cast3 Unmanaged.normal_functional_tdd
+
+normal_functional_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+normal_functional_td = _cast2 Unmanaged.normal_functional_td
+
+normal_functional_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+normal_functional_t = _cast1 Unmanaged.normal_functional_t
+
+normal_out_ttdG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_out_ttdG = _cast4 Unmanaged.normal_out_ttdG
+
+-- normal_out_ttd
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr Tensor
+--   -> CDouble
+--   -> IO (ForeignPtr Tensor)
+-- normal_out_ttd = _cast3 Unmanaged.normal_out_ttd
+
+-- normal_out_tt
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr Tensor
+--   -> IO (ForeignPtr Tensor)
+-- normal_out_tt = _cast2 Unmanaged.normal_out_tt
+
+normal_tdG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_tdG = _cast3 Unmanaged.normal_tdG
+
+normal_td
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+normal_td = _cast2 Unmanaged.normal_td
+
+normal_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+normal_t = _cast1 Unmanaged.normal_t
+
+normal_out_tdtG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_out_tdtG = _cast4 Unmanaged.normal_out_tdtG
+
+normal_out_tdt
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+normal_out_tdt = _cast3 Unmanaged.normal_out_tdt
+
+normal_dtG
+  :: CDouble
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_dtG = _cast3 Unmanaged.normal_dtG
+
+normal_dt
+  :: CDouble
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+normal_dt = _cast2 Unmanaged.normal_dt
+
+normal_out_tttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_out_tttG = _cast4 Unmanaged.normal_out_tttG
+
+normal_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+normal_out_ttt = _cast3 Unmanaged.normal_out_ttt
+
+normal_ttG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_ttG = _cast3 Unmanaged.normal_ttG
+
+normal_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+normal_tt = _cast2 Unmanaged.normal_tt
+
+normal_ddlGo
+  :: CDouble
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+normal_ddlGo = _cast5 Unmanaged.normal_ddlGo
+
+normal_ddlG
+  :: CDouble
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_ddlG = _cast4 Unmanaged.normal_ddlG
+
+normal_ddl
+  :: CDouble
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+normal_ddl = _cast3 Unmanaged.normal_ddl
+
+normal_out_tddlG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_out_tddlG = _cast5 Unmanaged.normal_out_tddlG
+
+normal_out_tddl
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+normal_out_tddl = _cast4 Unmanaged.normal_out_tddl
+
+alias_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+alias_t = _cast1 Unmanaged.alias_t
+
+_amp_foreach_non_finite_check_and_unscale__ltt
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+_amp_foreach_non_finite_check_and_unscale__ltt = _cast3 Unmanaged._amp_foreach_non_finite_check_and_unscale__ltt
+
+_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
+
+_foreach_add_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_add_ls = _cast2 Unmanaged._foreach_add_ls
+
+_foreach_add__ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_add__ls = _cast2 Unmanaged._foreach_add__ls
+
+_foreach_sub_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_sub_ls = _cast2 Unmanaged._foreach_sub_ls
+
+_foreach_sub__ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_sub__ls = _cast2 Unmanaged._foreach_sub__ls
+
+_foreach_mul_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_mul_ls = _cast2 Unmanaged._foreach_mul_ls
+
+_foreach_mul__ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_mul__ls = _cast2 Unmanaged._foreach_mul__ls
+
+_foreach_div_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_div_ls = _cast2 Unmanaged._foreach_div_ls
+
+_foreach_div__ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_div__ls = _cast2 Unmanaged._foreach_div__ls
+
+_foreach_clamp_min_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_clamp_min_ls = _cast2 Unmanaged._foreach_clamp_min_ls
+
+_foreach_clamp_min__ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_clamp_min__ls = _cast2 Unmanaged._foreach_clamp_min__ls
+
+_foreach_clamp_max_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_clamp_max_ls = _cast2 Unmanaged._foreach_clamp_max_ls
+
+_foreach_clamp_max__ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_clamp_max__ls = _cast2 Unmanaged._foreach_clamp_max__ls
+
+_foreach_maximum_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_maximum_ls = _cast2 Unmanaged._foreach_maximum_ls
+
+_foreach_maximum__ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_maximum__ls = _cast2 Unmanaged._foreach_maximum__ls
+
+_foreach_minimum_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_minimum_ls = _cast2 Unmanaged._foreach_minimum_ls
+
+_foreach_minimum__ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_minimum__ls = _cast2 Unmanaged._foreach_minimum__ls
+
+_foreach_add_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_add_lls = _cast3 Unmanaged._foreach_add_lls
+
+_foreach_add_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_add_ll = _cast2 Unmanaged._foreach_add_ll
+
+_foreach_add__lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_add__lls = _cast3 Unmanaged._foreach_add__lls
+
+_foreach_add__ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_add__ll = _cast2 Unmanaged._foreach_add__ll
+
+_foreach_sub_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_sub_lls = _cast3 Unmanaged._foreach_sub_lls
+
+_foreach_sub_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_sub_ll = _cast2 Unmanaged._foreach_sub_ll
+
+_foreach_sub__lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_sub__lls = _cast3 Unmanaged._foreach_sub__lls
+
+_foreach_sub__ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_sub__ll = _cast2 Unmanaged._foreach_sub__ll
+
+_foreach_mul_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_mul_ll = _cast2 Unmanaged._foreach_mul_ll
+
+_foreach_mul__ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_mul__ll = _cast2 Unmanaged._foreach_mul__ll
+
+_foreach_div_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_div_ll = _cast2 Unmanaged._foreach_div_ll
+
+_foreach_div__ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_div__ll = _cast2 Unmanaged._foreach_div__ll
+
+_foreach_clamp_min_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_clamp_min_ll = _cast2 Unmanaged._foreach_clamp_min_ll
+
+_foreach_clamp_min__ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_clamp_min__ll = _cast2 Unmanaged._foreach_clamp_min__ll
+
+_foreach_clamp_max_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_clamp_max_ll = _cast2 Unmanaged._foreach_clamp_max_ll
+
+_foreach_clamp_max__ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_clamp_max__ll = _cast2 Unmanaged._foreach_clamp_max__ll
+
+_foreach_maximum_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_maximum_ll = _cast2 Unmanaged._foreach_maximum_ll
+
+_foreach_maximum__ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_maximum__ll = _cast2 Unmanaged._foreach_maximum__ll
+
+_foreach_minimum_ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_minimum_ll = _cast2 Unmanaged._foreach_minimum_ll
+
+_foreach_minimum__ll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_minimum__ll = _cast2 Unmanaged._foreach_minimum__ll
+
+_foreach_add_lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_add_lA = _cast2 Unmanaged._foreach_add_lA
+
+_foreach_add__lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_add__lA = _cast2 Unmanaged._foreach_add__lA
+
+_foreach_sub_lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_sub_lA = _cast2 Unmanaged._foreach_sub_lA
+
+_foreach_sub__lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_sub__lA = _cast2 Unmanaged._foreach_sub__lA
+
+_foreach_div_lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_div_lA = _cast2 Unmanaged._foreach_div_lA
+
+_foreach_div__lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_div__lA = _cast2 Unmanaged._foreach_div__lA
+
+_foreach_mul_lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_mul_lA = _cast2 Unmanaged._foreach_mul_lA
+
+_foreach_mul__lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_mul__lA = _cast2 Unmanaged._foreach_mul__lA
+
+_foreach_clamp_min_lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_clamp_min_lA = _cast2 Unmanaged._foreach_clamp_min_lA
+
+_foreach_clamp_min__lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_clamp_min__lA = _cast2 Unmanaged._foreach_clamp_min__lA
+
+_foreach_clamp_max_lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_clamp_max_lA = _cast2 Unmanaged._foreach_clamp_max_lA
+
+_foreach_clamp_max__lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_clamp_max__lA = _cast2 Unmanaged._foreach_clamp_max__lA
+
+_foreach_maximum_lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_maximum_lA = _cast2 Unmanaged._foreach_maximum_lA
+
+_foreach_maximum__lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_maximum__lA = _cast2 Unmanaged._foreach_maximum__lA
+
+_foreach_minimum_lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_minimum_lA = _cast2 Unmanaged._foreach_minimum_lA
+
+_foreach_minimum__lA
+  :: ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_minimum__lA = _cast2 Unmanaged._foreach_minimum__lA
+
+_foreach_exp_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_exp_l = _cast1 Unmanaged._foreach_exp_l
+
+_foreach_zero__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_zero__l = _cast1 Unmanaged._foreach_zero__l
+
+_foreach_exp__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_exp__l = _cast1 Unmanaged._foreach_exp__l
+
+_foreach_sqrt_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_sqrt_l = _cast1 Unmanaged._foreach_sqrt_l
+
+_foreach_sqrt__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_sqrt__l = _cast1 Unmanaged._foreach_sqrt__l
+
+_foreach_abs_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_abs_l = _cast1 Unmanaged._foreach_abs_l
+
+_foreach_abs__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_abs__l = _cast1 Unmanaged._foreach_abs__l
+
+_foreach_acos_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_acos_l = _cast1 Unmanaged._foreach_acos_l
+
+_foreach_acos__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_acos__l = _cast1 Unmanaged._foreach_acos__l
+
+_foreach_asin_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_asin_l = _cast1 Unmanaged._foreach_asin_l
+
+_foreach_asin__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_asin__l = _cast1 Unmanaged._foreach_asin__l
+
+_foreach_atan_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_atan_l = _cast1 Unmanaged._foreach_atan_l
+
+_foreach_atan__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_atan__l = _cast1 Unmanaged._foreach_atan__l
+
+_foreach_ceil_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_ceil_l = _cast1 Unmanaged._foreach_ceil_l
+
+_foreach_ceil__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_ceil__l = _cast1 Unmanaged._foreach_ceil__l
+
+_foreach_cos_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_cos_l = _cast1 Unmanaged._foreach_cos_l
+
+_foreach_cos__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_cos__l = _cast1 Unmanaged._foreach_cos__l
+
+_foreach_cosh_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_cosh_l = _cast1 Unmanaged._foreach_cosh_l
+
+_foreach_cosh__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_cosh__l = _cast1 Unmanaged._foreach_cosh__l
+
+_foreach_erf_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_erf_l = _cast1 Unmanaged._foreach_erf_l
+
+_foreach_erf__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_erf__l = _cast1 Unmanaged._foreach_erf__l
+
+_foreach_erfc_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_erfc_l = _cast1 Unmanaged._foreach_erfc_l
+
+_foreach_erfc__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_erfc__l = _cast1 Unmanaged._foreach_erfc__l
+
+_foreach_expm1_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_expm1_l = _cast1 Unmanaged._foreach_expm1_l
+
+_foreach_expm1__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_expm1__l = _cast1 Unmanaged._foreach_expm1__l
+
+_foreach_floor_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_floor_l = _cast1 Unmanaged._foreach_floor_l
+
+_foreach_floor__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_floor__l = _cast1 Unmanaged._foreach_floor__l
+
+_foreach_log_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_log_l = _cast1 Unmanaged._foreach_log_l
+
+_foreach_log__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_log__l = _cast1 Unmanaged._foreach_log__l
+
+_foreach_log10_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_log10_l = _cast1 Unmanaged._foreach_log10_l
+
+_foreach_log10__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_log10__l = _cast1 Unmanaged._foreach_log10__l
+
+_foreach_log1p_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_log1p_l = _cast1 Unmanaged._foreach_log1p_l
+
+_foreach_log1p__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_log1p__l = _cast1 Unmanaged._foreach_log1p__l
+
+_foreach_log2_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_log2_l = _cast1 Unmanaged._foreach_log2_l
+
+_foreach_log2__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_log2__l = _cast1 Unmanaged._foreach_log2__l
+
+_foreach_neg_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_neg_l = _cast1 Unmanaged._foreach_neg_l
+
+_foreach_neg__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_neg__l = _cast1 Unmanaged._foreach_neg__l
+
+_foreach_tan_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_tan_l = _cast1 Unmanaged._foreach_tan_l
+
+_foreach_tan__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_tan__l = _cast1 Unmanaged._foreach_tan__l
+
+_foreach_tanh_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_tanh_l = _cast1 Unmanaged._foreach_tanh_l
+
+_foreach_tanh__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_tanh__l = _cast1 Unmanaged._foreach_tanh__l
+
+_foreach_sin_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_sin_l = _cast1 Unmanaged._foreach_sin_l
+
+_foreach_sin__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_sin__l = _cast1 Unmanaged._foreach_sin__l
+
+_foreach_sinh_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_sinh_l = _cast1 Unmanaged._foreach_sinh_l
+
+_foreach_sinh__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_sinh__l = _cast1 Unmanaged._foreach_sinh__l
+
+_foreach_round_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_round_l = _cast1 Unmanaged._foreach_round_l
+
+_foreach_round__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_round__l = _cast1 Unmanaged._foreach_round__l
+
+_foreach_lgamma_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_lgamma_l = _cast1 Unmanaged._foreach_lgamma_l
+
+_foreach_lgamma__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_lgamma__l = _cast1 Unmanaged._foreach_lgamma__l
+
+_foreach_frac_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_frac_l = _cast1 Unmanaged._foreach_frac_l
+
+_foreach_frac__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_frac__l = _cast1 Unmanaged._foreach_frac__l
+
+_foreach_reciprocal_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_reciprocal_l = _cast1 Unmanaged._foreach_reciprocal_l
+
+_foreach_reciprocal__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_reciprocal__l = _cast1 Unmanaged._foreach_reciprocal__l
+
+_foreach_sigmoid_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_sigmoid_l = _cast1 Unmanaged._foreach_sigmoid_l
+
+_foreach_sigmoid__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_sigmoid__l = _cast1 Unmanaged._foreach_sigmoid__l
+
+_foreach_trunc_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_trunc_l = _cast1 Unmanaged._foreach_trunc_l
+
+_foreach_trunc__l
+  :: ForeignPtr TensorList
+  -> IO (())
+_foreach_trunc__l = _cast1 Unmanaged._foreach_trunc__l
+
+_foreach_addcdiv__llls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_addcdiv__llls = _cast4 Unmanaged._foreach_addcdiv__llls
+
+_foreach_addcdiv__lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_addcdiv__lll = _cast3 Unmanaged._foreach_addcdiv__lll
+
+_foreach_addcmul__llls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_addcmul__llls = _cast4 Unmanaged._foreach_addcmul__llls
+
+_foreach_addcmul__lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_addcmul__lll = _cast3 Unmanaged._foreach_addcmul__lll
+
+_foreach_addcdiv__lllA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_addcdiv__lllA = _cast4 Unmanaged._foreach_addcdiv__lllA
+
+_foreach_addcdiv__lllt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (())
+_foreach_addcdiv__lllt = _cast4 Unmanaged._foreach_addcdiv__lllt
+
+_foreach_addcmul__lllA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (())
+_foreach_addcmul__lllA = _cast4 Unmanaged._foreach_addcmul__lllA
+
+_foreach_addcmul__lllt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (())
+_foreach_addcmul__lllt = _cast4 Unmanaged._foreach_addcmul__lllt
+
+_foreach_addcdiv_llls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_addcdiv_llls = _cast4 Unmanaged._foreach_addcdiv_llls
+
+_foreach_addcdiv_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_addcdiv_lll = _cast3 Unmanaged._foreach_addcdiv_lll
+
+_foreach_addcmul_llls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_addcmul_llls = _cast4 Unmanaged._foreach_addcmul_llls
+
+_foreach_addcmul_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_addcmul_lll = _cast3 Unmanaged._foreach_addcmul_lll
+
+_foreach_addcdiv_lllA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_addcdiv_lllA = _cast4 Unmanaged._foreach_addcdiv_lllA
+
+_foreach_addcdiv_lllt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+_foreach_addcdiv_lllt = _cast4 Unmanaged._foreach_addcdiv_lllt
+
+_foreach_addcmul_lllA
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr (StdVector Scalar)
+  -> IO (ForeignPtr TensorList)
+_foreach_addcmul_lllA = _cast4 Unmanaged._foreach_addcmul_lllA
+
+_foreach_addcmul_lllt
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+_foreach_addcmul_lllt = _cast4 Unmanaged._foreach_addcmul_lllt
+
+_foreach_norm_ls
+  :: ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_norm_ls = _cast2 Unmanaged._foreach_norm_ls
+
+_foreach_norm_l
+  :: ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_norm_l = _cast1 Unmanaged._foreach_norm_l
+
+_foreach_lerp_lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr TensorList)
+_foreach_lerp_lll = _cast3 Unmanaged._foreach_lerp_lll
+
+_foreach_lerp__lll
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> IO (())
+_foreach_lerp__lll = _cast3 Unmanaged._foreach_lerp__lll
+
+_foreach_lerp_lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr TensorList)
+_foreach_lerp_lls = _cast3 Unmanaged._foreach_lerp_lls
+
+_foreach_lerp__lls
+  :: ForeignPtr TensorList
+  -> ForeignPtr TensorList
+  -> ForeignPtr Scalar
+  -> IO (())
+_foreach_lerp__lls = _cast3 Unmanaged._foreach_lerp__lls
+
+bucketize_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bucketize_ttbb = _cast4 Unmanaged.bucketize_ttbb
+
+bucketize_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bucketize_ttb = _cast3 Unmanaged.bucketize_ttb
+
+bucketize_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bucketize_tt = _cast2 Unmanaged.bucketize_tt
+
+bucketize_out_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bucketize_out_tttbb = _cast5 Unmanaged.bucketize_out_tttbb
+
+bucketize_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bucketize_out_tttb = _cast4 Unmanaged.bucketize_out_tttb
+
+bucketize_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bucketize_out_ttt = _cast3 Unmanaged.bucketize_out_ttt
+
+bucketize_stbb
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bucketize_stbb = _cast4 Unmanaged.bucketize_stbb
+
+bucketize_stb
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bucketize_stb = _cast3 Unmanaged.bucketize_stb
+
+bucketize_st
+  :: ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+bucketize_st = _cast2 Unmanaged.bucketize_st
+
+searchsorted_ttbbst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+searchsorted_ttbbst = _cast6 Unmanaged.searchsorted_ttbbst
+
+searchsorted_ttbbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+searchsorted_ttbbs = _cast5 Unmanaged.searchsorted_ttbbs
+
+searchsorted_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+searchsorted_ttbb = _cast4 Unmanaged.searchsorted_ttbb
+
+searchsorted_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+searchsorted_ttb = _cast3 Unmanaged.searchsorted_ttb
+
+searchsorted_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+searchsorted_tt = _cast2 Unmanaged.searchsorted_tt
+
+searchsorted_out_tttbbst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_tttbbst = _cast7 Unmanaged.searchsorted_out_tttbbst
+
+searchsorted_out_tttbbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_tttbbs = _cast6 Unmanaged.searchsorted_out_tttbbs
+
+searchsorted_out_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_tttbb = _cast5 Unmanaged.searchsorted_out_tttbb
+
+searchsorted_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_tttb = _cast4 Unmanaged.searchsorted_out_tttb
+
+searchsorted_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+searchsorted_out_ttt = _cast3 Unmanaged.searchsorted_out_ttt
+
+searchsorted_tsbbst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+searchsorted_tsbbst = _cast6 Unmanaged.searchsorted_tsbbst
+
+searchsorted_tsbbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+searchsorted_tsbbs = _cast5 Unmanaged.searchsorted_tsbbs
+
+searchsorted_tsbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+searchsorted_tsbb = _cast4 Unmanaged.searchsorted_tsbb
+
+searchsorted_tsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+searchsorted_tsb = _cast3 Unmanaged.searchsorted_tsb
+
+searchsorted_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+searchsorted_ts = _cast2 Unmanaged.searchsorted_ts
+
+_convert_indices_from_coo_to_csr_tlb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_coo_to_csr_tlb = _cast3 Unmanaged._convert_indices_from_coo_to_csr_tlb
+
+_convert_indices_from_coo_to_csr_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_coo_to_csr_tl = _cast2 Unmanaged._convert_indices_from_coo_to_csr_tl
+
+_convert_indices_from_coo_to_csr_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_coo_to_csr_out_ttlb = _cast4 Unmanaged._convert_indices_from_coo_to_csr_out_ttlb
+
+_convert_indices_from_coo_to_csr_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_coo_to_csr_out_ttl = _cast3 Unmanaged._convert_indices_from_coo_to_csr_out_ttl
+
+_convert_indices_from_csr_to_coo_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_csr_to_coo_ttbb = _cast4 Unmanaged._convert_indices_from_csr_to_coo_ttbb
+
+_convert_indices_from_csr_to_coo_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_csr_to_coo_ttb = _cast3 Unmanaged._convert_indices_from_csr_to_coo_ttb
+
+_convert_indices_from_csr_to_coo_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_csr_to_coo_tt = _cast2 Unmanaged._convert_indices_from_csr_to_coo_tt
+
+_convert_indices_from_csr_to_coo_out_tttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_csr_to_coo_out_tttbb = _cast5 Unmanaged._convert_indices_from_csr_to_coo_out_tttbb
+
+_convert_indices_from_csr_to_coo_out_tttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_csr_to_coo_out_tttb = _cast4 Unmanaged._convert_indices_from_csr_to_coo_out_tttb
+
+_convert_indices_from_csr_to_coo_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_convert_indices_from_csr_to_coo_out_ttt = _cast3 Unmanaged._convert_indices_from_csr_to_coo_out_ttt
+
+mse_loss_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mse_loss_out_tttl = _cast4 Unmanaged.mse_loss_out_tttl
+
+mse_loss_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mse_loss_out_ttt = _cast3 Unmanaged.mse_loss_out_ttt
+
+mse_loss_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mse_loss_ttl = _cast3 Unmanaged.mse_loss_ttl
+
+mse_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mse_loss_tt = _cast2 Unmanaged.mse_loss_tt
+
+mse_loss_backward_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mse_loss_backward_out_ttttl = _cast5 Unmanaged.mse_loss_backward_out_ttttl
+
+mse_loss_backward_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+mse_loss_backward_tttl = _cast4 Unmanaged.mse_loss_backward_tttl
+
+l1_loss_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+l1_loss_ttl = _cast3 Unmanaged.l1_loss_ttl
+
+l1_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+l1_loss_tt = _cast2 Unmanaged.l1_loss_tt
+
+multi_margin_loss_out_tttsstl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_out_tttsstl = _cast7 Unmanaged.multi_margin_loss_out_tttsstl
+
+multi_margin_loss_out_tttsst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_out_tttsst = _cast6 Unmanaged.multi_margin_loss_out_tttsst
+
+multi_margin_loss_out_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_out_tttss = _cast5 Unmanaged.multi_margin_loss_out_tttss
+
+multi_margin_loss_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_out_ttts = _cast4 Unmanaged.multi_margin_loss_out_ttts
+
+multi_margin_loss_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_out_ttt = _cast3 Unmanaged.multi_margin_loss_out_ttt
+
+multi_margin_loss_ttsstl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_ttsstl = _cast6 Unmanaged.multi_margin_loss_ttsstl
+
+multi_margin_loss_ttsst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_ttsst = _cast5 Unmanaged.multi_margin_loss_ttsst
+
+multi_margin_loss_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_ttss = _cast4 Unmanaged.multi_margin_loss_ttss
+
+multi_margin_loss_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_tts = _cast3 Unmanaged.multi_margin_loss_tts
+
+multi_margin_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_tt = _cast2 Unmanaged.multi_margin_loss_tt
+
+multi_margin_loss_backward_out_ttttsstl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_backward_out_ttttsstl = _cast8 Unmanaged.multi_margin_loss_backward_out_ttttsstl
+
+multi_margin_loss_backward_out_ttttsst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_backward_out_ttttsst = _cast7 Unmanaged.multi_margin_loss_backward_out_ttttsst
+
+multi_margin_loss_backward_out_ttttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_backward_out_ttttss = _cast6 Unmanaged.multi_margin_loss_backward_out_ttttss
+
+multi_margin_loss_backward_tttsstl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_backward_tttsstl = _cast7 Unmanaged.multi_margin_loss_backward_tttsstl
+
+multi_margin_loss_backward_tttsst
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_backward_tttsst = _cast6 Unmanaged.multi_margin_loss_backward_tttsst
+
+multi_margin_loss_backward_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+multi_margin_loss_backward_tttss = _cast5 Unmanaged.multi_margin_loss_backward_tttss
+
+multilabel_margin_loss_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+multilabel_margin_loss_out_tttl = _cast4 Unmanaged.multilabel_margin_loss_out_tttl
+
+multilabel_margin_loss_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multilabel_margin_loss_out_ttt = _cast3 Unmanaged.multilabel_margin_loss_out_ttt
+
+multilabel_margin_loss_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+multilabel_margin_loss_ttl = _cast3 Unmanaged.multilabel_margin_loss_ttl
+
+multilabel_margin_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multilabel_margin_loss_tt = _cast2 Unmanaged.multilabel_margin_loss_tt
+
+multilabel_margin_loss_forward_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+multilabel_margin_loss_forward_out_ttttl = _cast5 Unmanaged.multilabel_margin_loss_forward_out_ttttl
+
+multilabel_margin_loss_forward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+multilabel_margin_loss_forward_ttl = _cast3 Unmanaged.multilabel_margin_loss_forward_ttl
+
+multilabel_margin_loss_backward_out_ttttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multilabel_margin_loss_backward_out_ttttlt = _cast6 Unmanaged.multilabel_margin_loss_backward_out_ttttlt
+
+multilabel_margin_loss_backward_tttlt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+multilabel_margin_loss_backward_tttlt = _cast5 Unmanaged.multilabel_margin_loss_backward_tttlt
+
+nll_loss_out_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss_out_ttttll = _cast6 Unmanaged.nll_loss_out_ttttll
+
+nll_loss_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss_out_ttttl = _cast5 Unmanaged.nll_loss_out_ttttl
+
+nll_loss_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss_out_tttt = _cast4 Unmanaged.nll_loss_out_tttt
+
+nll_loss_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss_out_ttt = _cast3 Unmanaged.nll_loss_out_ttt
+
+nll_loss_nd_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss_nd_tttll = _cast5 Unmanaged.nll_loss_nd_tttll
+
+nll_loss_nd_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss_nd_tttl = _cast4 Unmanaged.nll_loss_nd_tttl
+
+nll_loss_nd_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss_nd_ttt = _cast3 Unmanaged.nll_loss_nd_ttt
+
+nll_loss_nd_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss_nd_tt = _cast2 Unmanaged.nll_loss_nd_tt
+
diff --git a/src/Torch/Internal/Managed/Native/Native9.hs b/src/Torch/Internal/Managed/Native/Native9.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Native/Native9.hs
@@ -0,0 +1,2313 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.Native.Native9 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Native.Native9 as Unmanaged
+
+
+nll_loss_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss_tttll = _cast5 Unmanaged.nll_loss_tttll
+
+nll_loss_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss_tttl = _cast4 Unmanaged.nll_loss_tttl
+
+nll_loss_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss_ttt = _cast3 Unmanaged.nll_loss_ttt
+
+nll_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss_tt = _cast2 Unmanaged.nll_loss_tt
+
+nll_loss_forward_out_tttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nll_loss_forward_out_tttttll = _cast7 Unmanaged.nll_loss_forward_out_tttttll
+
+nll_loss_forward_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nll_loss_forward_tttll = _cast5 Unmanaged.nll_loss_forward_tttll
+
+nll_loss_backward_out_tttttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss_backward_out_tttttllt = _cast8 Unmanaged.nll_loss_backward_out_tttttllt
+
+nll_loss_backward_ttttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss_backward_ttttllt = _cast7 Unmanaged.nll_loss_backward_ttttllt
+
+nll_loss2d_out_ttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_out_ttttll = _cast6 Unmanaged.nll_loss2d_out_ttttll
+
+nll_loss2d_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_out_ttttl = _cast5 Unmanaged.nll_loss2d_out_ttttl
+
+nll_loss2d_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_out_tttt = _cast4 Unmanaged.nll_loss2d_out_tttt
+
+nll_loss2d_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_out_ttt = _cast3 Unmanaged.nll_loss2d_out_ttt
+
+nll_loss2d_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_tttll = _cast5 Unmanaged.nll_loss2d_tttll
+
+nll_loss2d_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_tttl = _cast4 Unmanaged.nll_loss2d_tttl
+
+nll_loss2d_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_ttt = _cast3 Unmanaged.nll_loss2d_ttt
+
+nll_loss2d_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_tt = _cast2 Unmanaged.nll_loss2d_tt
+
+nll_loss2d_forward_out_tttttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nll_loss2d_forward_out_tttttll = _cast7 Unmanaged.nll_loss2d_forward_out_tttttll
+
+nll_loss2d_forward_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+nll_loss2d_forward_tttll = _cast5 Unmanaged.nll_loss2d_forward_tttll
+
+nll_loss2d_backward_out_tttttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_backward_out_tttttllt = _cast8 Unmanaged.nll_loss2d_backward_out_tttttllt
+
+nll_loss2d_backward_ttttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+nll_loss2d_backward_ttttllt = _cast7 Unmanaged.nll_loss2d_backward_ttttllt
+
+smooth_l1_loss_out_tttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+smooth_l1_loss_out_tttld = _cast5 Unmanaged.smooth_l1_loss_out_tttld
+
+smooth_l1_loss_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+smooth_l1_loss_out_tttl = _cast4 Unmanaged.smooth_l1_loss_out_tttl
+
+smooth_l1_loss_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+smooth_l1_loss_out_ttt = _cast3 Unmanaged.smooth_l1_loss_out_ttt
+
+smooth_l1_loss_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+smooth_l1_loss_ttld = _cast4 Unmanaged.smooth_l1_loss_ttld
+
+smooth_l1_loss_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+smooth_l1_loss_ttl = _cast3 Unmanaged.smooth_l1_loss_ttl
+
+smooth_l1_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+smooth_l1_loss_tt = _cast2 Unmanaged.smooth_l1_loss_tt
+
+smooth_l1_loss_backward_out_ttttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+smooth_l1_loss_backward_out_ttttld = _cast6 Unmanaged.smooth_l1_loss_backward_out_ttttld
+
+smooth_l1_loss_backward_tttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+smooth_l1_loss_backward_tttld = _cast5 Unmanaged.smooth_l1_loss_backward_tttld
+
+huber_loss_out_tttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+huber_loss_out_tttld = _cast5 Unmanaged.huber_loss_out_tttld
+
+huber_loss_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+huber_loss_out_tttl = _cast4 Unmanaged.huber_loss_out_tttl
+
+huber_loss_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+huber_loss_out_ttt = _cast3 Unmanaged.huber_loss_out_ttt
+
+huber_loss_ttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+huber_loss_ttld = _cast4 Unmanaged.huber_loss_ttld
+
+huber_loss_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+huber_loss_ttl = _cast3 Unmanaged.huber_loss_ttl
+
+huber_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+huber_loss_tt = _cast2 Unmanaged.huber_loss_tt
+
+huber_loss_backward_out_ttttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+huber_loss_backward_out_ttttld = _cast6 Unmanaged.huber_loss_backward_out_ttttld
+
+huber_loss_backward_tttld
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+huber_loss_backward_tttld = _cast5 Unmanaged.huber_loss_backward_tttld
+
+soft_margin_loss_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+soft_margin_loss_out_tttl = _cast4 Unmanaged.soft_margin_loss_out_tttl
+
+soft_margin_loss_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+soft_margin_loss_out_ttt = _cast3 Unmanaged.soft_margin_loss_out_ttt
+
+soft_margin_loss_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+soft_margin_loss_ttl = _cast3 Unmanaged.soft_margin_loss_ttl
+
+soft_margin_loss_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+soft_margin_loss_tt = _cast2 Unmanaged.soft_margin_loss_tt
+
+soft_margin_loss_backward_out_ttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+soft_margin_loss_backward_out_ttttl = _cast5 Unmanaged.soft_margin_loss_backward_out_ttttl
+
+soft_margin_loss_backward_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+soft_margin_loss_backward_tttl = _cast4 Unmanaged.soft_margin_loss_backward_tttl
+
+elu_out_ttsss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu_out_ttsss = _cast5 Unmanaged.elu_out_ttsss
+
+elu_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu_out_ttss = _cast4 Unmanaged.elu_out_ttss
+
+elu_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu_out_tts = _cast3 Unmanaged.elu_out_tts
+
+elu_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+elu_out_tt = _cast2 Unmanaged.elu_out_tt
+
+elu_tsss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu_tsss = _cast4 Unmanaged.elu_tsss
+
+elu_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu_tss = _cast3 Unmanaged.elu_tss
+
+elu_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu_ts = _cast2 Unmanaged.elu_ts
+
+elu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+elu_t = _cast1 Unmanaged.elu_t
+
+elu_backward_out_ttsssbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+elu_backward_out_ttsssbt = _cast7 Unmanaged.elu_backward_out_ttsssbt
+
+elu_backward_tsssbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+elu_backward_tsssbt = _cast6 Unmanaged.elu_backward_tsssbt
+
+elu__tsss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu__tsss = _cast4 Unmanaged.elu__tsss
+
+elu__tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu__tss = _cast3 Unmanaged.elu__tss
+
+elu__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+elu__ts = _cast2 Unmanaged.elu__ts
+
+elu__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+elu__t = _cast1 Unmanaged.elu__t
+
+glu_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+glu_out_ttl = _cast3 Unmanaged.glu_out_ttl
+
+glu_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+glu_out_tt = _cast2 Unmanaged.glu_out_tt
+
+glu_tl
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+glu_tl = _cast2 Unmanaged.glu_tl
+
+glu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+glu_t = _cast1 Unmanaged.glu_t
+
+glu_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+glu_backward_out_tttl = _cast4 Unmanaged.glu_backward_out_tttl
+
+glu_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+glu_backward_ttl = _cast3 Unmanaged.glu_backward_ttl
+
+glu_jvp_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+glu_jvp_tttl = _cast4 Unmanaged.glu_jvp_tttl
+
+glu_backward_jvp_tttttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+glu_backward_jvp_tttttl = _cast6 Unmanaged.glu_backward_jvp_tttttl
+
+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_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardsigmoid_backward_out_ttt = _cast3 Unmanaged.hardsigmoid_backward_out_ttt
+
+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
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardtanh_out_ttss = _cast4 Unmanaged.hardtanh_out_ttss
+
+hardtanh_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardtanh_out_tts = _cast3 Unmanaged.hardtanh_out_tts
+
+hardtanh_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardtanh_out_tt = _cast2 Unmanaged.hardtanh_out_tt
+
+hardtanh_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardtanh_tss = _cast3 Unmanaged.hardtanh_tss
+
+hardtanh_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardtanh_ts = _cast2 Unmanaged.hardtanh_ts
+
+hardtanh_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardtanh_t = _cast1 Unmanaged.hardtanh_t
+
+hardtanh_backward_out_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardtanh_backward_out_tttss = _cast5 Unmanaged.hardtanh_backward_out_tttss
+
+hardtanh_backward_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardtanh_backward_ttss = _cast4 Unmanaged.hardtanh_backward_ttss
+
+hardtanh__tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardtanh__tss = _cast3 Unmanaged.hardtanh__tss
+
+hardtanh__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+hardtanh__ts = _cast2 Unmanaged.hardtanh__ts
+
+hardtanh__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardtanh__t = _cast1 Unmanaged.hardtanh__t
+
+hardswish_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardswish_out_tt = _cast2 Unmanaged.hardswish_out_tt
+
+hardswish_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardswish_t = _cast1 Unmanaged.hardswish_t
+
+hardswish__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardswish__t = _cast1 Unmanaged.hardswish__t
+
+hardswish_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+hardswish_backward_tt = _cast2 Unmanaged.hardswish_backward_tt
+
+leaky_relu_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+leaky_relu_out_tts = _cast3 Unmanaged.leaky_relu_out_tts
+
+leaky_relu_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+leaky_relu_out_tt = _cast2 Unmanaged.leaky_relu_out_tt
+
+leaky_relu_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+leaky_relu_ts = _cast2 Unmanaged.leaky_relu_ts
+
+leaky_relu_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+leaky_relu_t = _cast1 Unmanaged.leaky_relu_t
+
+leaky_relu_backward_out_tttsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+leaky_relu_backward_out_tttsb = _cast5 Unmanaged.leaky_relu_backward_out_tttsb
+
+leaky_relu_backward_ttsb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+leaky_relu_backward_ttsb = _cast4 Unmanaged.leaky_relu_backward_ttsb
+
+leaky_relu__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+leaky_relu__ts = _cast2 Unmanaged.leaky_relu__ts
+
+leaky_relu__t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+leaky_relu__t = _cast1 Unmanaged.leaky_relu__t
+
+log_sigmoid_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log_sigmoid_out_tt = _cast2 Unmanaged.log_sigmoid_out_tt
+
+log_sigmoid_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log_sigmoid_t = _cast1 Unmanaged.log_sigmoid_t
+
+log_sigmoid_forward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+log_sigmoid_forward_out_ttt = _cast3 Unmanaged.log_sigmoid_forward_out_ttt
+
+log_sigmoid_forward_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+log_sigmoid_forward_t = _cast1 Unmanaged.log_sigmoid_forward_t
+
+log_sigmoid_backward_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log_sigmoid_backward_out_tttt = _cast4 Unmanaged.log_sigmoid_backward_out_tttt
+
+log_sigmoid_backward_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+log_sigmoid_backward_ttt = _cast3 Unmanaged.log_sigmoid_backward_ttt
+
+rrelu_with_noise_out_tttssbG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_out_tttssbG = _cast7 Unmanaged.rrelu_with_noise_out_tttssbG
+
+rrelu_with_noise_out_tttssb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_out_tttssb = _cast6 Unmanaged.rrelu_with_noise_out_tttssb
+
+rrelu_with_noise_out_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_out_tttss = _cast5 Unmanaged.rrelu_with_noise_out_tttss
+
+rrelu_with_noise_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_out_ttts = _cast4 Unmanaged.rrelu_with_noise_out_ttts
+
+rrelu_with_noise_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_out_ttt = _cast3 Unmanaged.rrelu_with_noise_out_ttt
+
+rrelu_with_noise_ttssbG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_ttssbG = _cast6 Unmanaged.rrelu_with_noise_ttssbG
+
+rrelu_with_noise_ttssb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_ttssb = _cast5 Unmanaged.rrelu_with_noise_ttssb
+
+rrelu_with_noise_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_ttss = _cast4 Unmanaged.rrelu_with_noise_ttss
+
+rrelu_with_noise_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_tts = _cast3 Unmanaged.rrelu_with_noise_tts
+
+rrelu_with_noise_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_tt = _cast2 Unmanaged.rrelu_with_noise_tt
+
+rrelu_with_noise_backward_tttssbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise_backward_tttssbb = _cast7 Unmanaged.rrelu_with_noise_backward_tttssbb
+
+rrelu_with_noise__ttssbG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise__ttssbG = _cast6 Unmanaged.rrelu_with_noise__ttssbG
+
+rrelu_with_noise__ttssb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise__ttssb = _cast5 Unmanaged.rrelu_with_noise__ttssb
+
+rrelu_with_noise__ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise__ttss = _cast4 Unmanaged.rrelu_with_noise__ttss
+
+rrelu_with_noise__tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise__tts = _cast3 Unmanaged.rrelu_with_noise__tts
+
+rrelu_with_noise__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+rrelu_with_noise__tt = _cast2 Unmanaged.rrelu_with_noise__tt
+
+softplus_out_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softplus_out_ttss = _cast4 Unmanaged.softplus_out_ttss
+
+softplus_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softplus_out_tts = _cast3 Unmanaged.softplus_out_tts
+
+softplus_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+softplus_out_tt = _cast2 Unmanaged.softplus_out_tt
+
+softplus_tss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softplus_tss = _cast3 Unmanaged.softplus_tss
+
+softplus_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softplus_ts = _cast2 Unmanaged.softplus_ts
+
+softplus_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+softplus_t = _cast1 Unmanaged.softplus_t
+
+softplus_backward_out_tttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softplus_backward_out_tttss = _cast5 Unmanaged.softplus_backward_out_tttss
+
+softplus_backward_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softplus_backward_ttss = _cast4 Unmanaged.softplus_backward_ttss
+
+softshrink_out_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softshrink_out_tts = _cast3 Unmanaged.softshrink_out_tts
+
+softshrink_out_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+softshrink_out_tt = _cast2 Unmanaged.softshrink_out_tt
+
+softshrink_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softshrink_ts = _cast2 Unmanaged.softshrink_ts
+
+softshrink_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+softshrink_t = _cast1 Unmanaged.softshrink_t
+
+softshrink_backward_out_ttts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softshrink_backward_out_ttts = _cast4 Unmanaged.softshrink_backward_out_ttts
+
+softshrink_backward_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+softshrink_backward_tts = _cast3 Unmanaged.softshrink_backward_tts
+
+adaptive_avg_pool2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+adaptive_avg_pool2d_out_ttl = _cast3 Unmanaged.adaptive_avg_pool2d_out_ttl
+
+adaptive_avg_pool2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+adaptive_avg_pool2d_tl = _cast2 Unmanaged.adaptive_avg_pool2d_tl
+
+mkldnn_adaptive_avg_pool2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_adaptive_avg_pool2d_tl = _cast2 Unmanaged.mkldnn_adaptive_avg_pool2d_tl
+
+mkldnn_adaptive_avg_pool2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+mkldnn_adaptive_avg_pool2d_out_ttl = _cast3 Unmanaged.mkldnn_adaptive_avg_pool2d_out_ttl
+
+mkldnn_adaptive_avg_pool2d_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+mkldnn_adaptive_avg_pool2d_backward_tt = _cast2 Unmanaged.mkldnn_adaptive_avg_pool2d_backward_tt
+
+_adaptive_avg_pool2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_adaptive_avg_pool2d_tl = _cast2 Unmanaged._adaptive_avg_pool2d_tl
+
+_adaptive_avg_pool2d_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_adaptive_avg_pool2d_backward_tt = _cast2 Unmanaged._adaptive_avg_pool2d_backward_tt
+
+adaptive_avg_pool3d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+adaptive_avg_pool3d_out_ttl = _cast3 Unmanaged.adaptive_avg_pool3d_out_ttl
+
+adaptive_avg_pool3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+adaptive_avg_pool3d_tl = _cast2 Unmanaged.adaptive_avg_pool3d_tl
+
+_adaptive_avg_pool3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_adaptive_avg_pool3d_tl = _cast2 Unmanaged._adaptive_avg_pool3d_tl
+
+adaptive_avg_pool3d_backward_out_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+adaptive_avg_pool3d_backward_out_ttt = _cast3 Unmanaged.adaptive_avg_pool3d_backward_out_ttt
+
+_adaptive_avg_pool3d_backward_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_adaptive_avg_pool3d_backward_tt = _cast2 Unmanaged._adaptive_avg_pool3d_backward_tt
+
+adaptive_max_pool2d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool2d_out_tttl = _cast4 Unmanaged.adaptive_max_pool2d_out_tttl
+
+adaptive_max_pool2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool2d_tl = _cast2 Unmanaged.adaptive_max_pool2d_tl
+
+adaptive_max_pool2d_backward_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+adaptive_max_pool2d_backward_out_tttt = _cast4 Unmanaged.adaptive_max_pool2d_backward_out_tttt
+
+adaptive_max_pool2d_backward_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+adaptive_max_pool2d_backward_ttt = _cast3 Unmanaged.adaptive_max_pool2d_backward_ttt
+
+adaptive_max_pool3d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool3d_out_tttl = _cast4 Unmanaged.adaptive_max_pool3d_out_tttl
+
+adaptive_max_pool3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool3d_tl = _cast2 Unmanaged.adaptive_max_pool3d_tl
+
+adaptive_max_pool3d_backward_out_tttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+adaptive_max_pool3d_backward_out_tttt = _cast4 Unmanaged.adaptive_max_pool3d_backward_out_tttt
+
+adaptive_max_pool3d_backward_ttt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+adaptive_max_pool3d_backward_ttt = _cast3 Unmanaged.adaptive_max_pool3d_backward_ttt
+
+avg_pool2d_out_ttlllbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_out_ttlllbbl = _cast8 Unmanaged.avg_pool2d_out_ttlllbbl
+
+avg_pool2d_out_ttlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_out_ttlllbb = _cast7 Unmanaged.avg_pool2d_out_ttlllbb
+
+avg_pool2d_out_ttlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_out_ttlllb = _cast6 Unmanaged.avg_pool2d_out_ttlllb
+
+avg_pool2d_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_out_ttlll = _cast5 Unmanaged.avg_pool2d_out_ttlll
+
+avg_pool2d_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_out_ttll = _cast4 Unmanaged.avg_pool2d_out_ttll
+
+avg_pool2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_out_ttl = _cast3 Unmanaged.avg_pool2d_out_ttl
+
+avg_pool2d_tlllbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_tlllbbl = _cast7 Unmanaged.avg_pool2d_tlllbbl
+
+avg_pool2d_tlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_tlllbb = _cast6 Unmanaged.avg_pool2d_tlllbb
+
+avg_pool2d_tlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_tlllb = _cast5 Unmanaged.avg_pool2d_tlllb
+
+avg_pool2d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_tlll = _cast4 Unmanaged.avg_pool2d_tlll
+
+avg_pool2d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_tll = _cast3 Unmanaged.avg_pool2d_tll
+
+avg_pool2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_tl = _cast2 Unmanaged.avg_pool2d_tl
+
+avg_pool2d_backward_out_tttlllbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_backward_out_tttlllbbl = _cast9 Unmanaged.avg_pool2d_backward_out_tttlllbbl
+
+avg_pool2d_backward_ttlllbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+avg_pool2d_backward_ttlllbbl = _cast8 Unmanaged.avg_pool2d_backward_ttlllbbl
+
+avg_pool3d_out_ttlllbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_out_ttlllbbl = _cast8 Unmanaged.avg_pool3d_out_ttlllbbl
+
+avg_pool3d_out_ttlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_out_ttlllbb = _cast7 Unmanaged.avg_pool3d_out_ttlllbb
+
+avg_pool3d_out_ttlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_out_ttlllb = _cast6 Unmanaged.avg_pool3d_out_ttlllb
+
+avg_pool3d_out_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_out_ttlll = _cast5 Unmanaged.avg_pool3d_out_ttlll
+
+avg_pool3d_out_ttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_out_ttll = _cast4 Unmanaged.avg_pool3d_out_ttll
+
+avg_pool3d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_out_ttl = _cast3 Unmanaged.avg_pool3d_out_ttl
+
+avg_pool3d_tlllbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_tlllbbl = _cast7 Unmanaged.avg_pool3d_tlllbbl
+
+avg_pool3d_tlllbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_tlllbb = _cast6 Unmanaged.avg_pool3d_tlllbb
+
+avg_pool3d_tlllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_tlllb = _cast5 Unmanaged.avg_pool3d_tlllb
+
+avg_pool3d_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_tlll = _cast4 Unmanaged.avg_pool3d_tlll
+
+avg_pool3d_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_tll = _cast3 Unmanaged.avg_pool3d_tll
+
+avg_pool3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_tl = _cast2 Unmanaged.avg_pool3d_tl
+
+avg_pool3d_backward_out_tttlllbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_backward_out_tttlllbbl = _cast9 Unmanaged.avg_pool3d_backward_out_tttlllbbl
+
+avg_pool3d_backward_ttlllbbl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+avg_pool3d_backward_ttlllbbl = _cast8 Unmanaged.avg_pool3d_backward_ttlllbbl
+
+fractional_max_pool2d_out_tttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+fractional_max_pool2d_out_tttllt = _cast6 Unmanaged.fractional_max_pool2d_out_tttllt
+
+fractional_max_pool2d_tllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+fractional_max_pool2d_tllt = _cast4 Unmanaged.fractional_max_pool2d_tllt
+
+fractional_max_pool2d_backward_out_tttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fractional_max_pool2d_backward_out_tttllt = _cast6 Unmanaged.fractional_max_pool2d_backward_out_tttllt
+
+fractional_max_pool2d_backward_ttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fractional_max_pool2d_backward_ttllt = _cast5 Unmanaged.fractional_max_pool2d_backward_ttllt
+
+fractional_max_pool3d_out_tttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+fractional_max_pool3d_out_tttllt = _cast6 Unmanaged.fractional_max_pool3d_out_tttllt
+
+fractional_max_pool3d_tllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+fractional_max_pool3d_tllt = _cast4 Unmanaged.fractional_max_pool3d_tllt
+
+fractional_max_pool3d_backward_out_tttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fractional_max_pool3d_backward_out_tttllt = _cast6 Unmanaged.fractional_max_pool3d_backward_out_tttllt
+
+fractional_max_pool3d_backward_ttllt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+fractional_max_pool3d_backward_ttllt = _cast5 Unmanaged.fractional_max_pool3d_backward_ttllt
+
+max_pool2d_with_indices_out_tttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttllllb = _cast8 Unmanaged.max_pool2d_with_indices_out_tttllllb
+
+max_pool2d_with_indices_out_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttllll = _cast7 Unmanaged.max_pool2d_with_indices_out_tttllll
+
+max_pool2d_with_indices_out_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttlll = _cast6 Unmanaged.max_pool2d_with_indices_out_tttlll
+
+max_pool2d_with_indices_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttll = _cast5 Unmanaged.max_pool2d_with_indices_out_tttll
+
+max_pool2d_with_indices_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttl = _cast4 Unmanaged.max_pool2d_with_indices_out_tttl
+
+max_pool2d_with_indices_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tllllb = _cast6 Unmanaged.max_pool2d_with_indices_tllllb
+
+max_pool2d_with_indices_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tllll = _cast5 Unmanaged.max_pool2d_with_indices_tllll
+
+max_pool2d_with_indices_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tlll = _cast4 Unmanaged.max_pool2d_with_indices_tlll
+
+max_pool2d_with_indices_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tll = _cast3 Unmanaged.max_pool2d_with_indices_tll
+
+max_pool2d_with_indices_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tl = _cast2 Unmanaged.max_pool2d_with_indices_tl
+
+max_pool2d_with_indices_backward_out_tttllllbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+max_pool2d_with_indices_backward_out_tttllllbt = _cast9 Unmanaged.max_pool2d_with_indices_backward_out_tttllllbt
+
+max_pool2d_with_indices_backward_ttllllbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+max_pool2d_with_indices_backward_ttllllbt = _cast8 Unmanaged.max_pool2d_with_indices_backward_ttllllbt
+
+max_pool3d_with_indices_out_tttllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttllllb = _cast8 Unmanaged.max_pool3d_with_indices_out_tttllllb
+
+max_pool3d_with_indices_out_tttllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttllll = _cast7 Unmanaged.max_pool3d_with_indices_out_tttllll
+
+max_pool3d_with_indices_out_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttlll = _cast6 Unmanaged.max_pool3d_with_indices_out_tttlll
+
+max_pool3d_with_indices_out_tttll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttll = _cast5 Unmanaged.max_pool3d_with_indices_out_tttll
+
+max_pool3d_with_indices_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttl = _cast4 Unmanaged.max_pool3d_with_indices_out_tttl
+
+max_pool3d_with_indices_tllllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tllllb = _cast6 Unmanaged.max_pool3d_with_indices_tllllb
+
+max_pool3d_with_indices_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tllll = _cast5 Unmanaged.max_pool3d_with_indices_tllll
+
+max_pool3d_with_indices_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tlll = _cast4 Unmanaged.max_pool3d_with_indices_tlll
+
+max_pool3d_with_indices_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tll = _cast3 Unmanaged.max_pool3d_with_indices_tll
+
+max_pool3d_with_indices_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tl = _cast2 Unmanaged.max_pool3d_with_indices_tl
+
+max_pool3d_with_indices_backward_out_tttllllbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+max_pool3d_with_indices_backward_out_tttllllbt = _cast9 Unmanaged.max_pool3d_with_indices_backward_out_tttllllbt
+
+max_pool3d_with_indices_backward_ttllllbt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+max_pool3d_with_indices_backward_ttllllbt = _cast8 Unmanaged.max_pool3d_with_indices_backward_ttllllbt
+
+max_unpool2d_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_unpool2d_out_tttl = _cast4 Unmanaged.max_unpool2d_out_tttl
+
+max_unpool2d_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_unpool2d_ttl = _cast3 Unmanaged.max_unpool2d_ttl
+
+max_unpool3d_out_tttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_unpool3d_out_tttlll = _cast6 Unmanaged.max_unpool3d_out_tttlll
+
+max_unpool3d_ttlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+max_unpool3d_ttlll = _cast5 Unmanaged.max_unpool3d_ttlll
+
+reflection_pad1d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad1d_out_ttl = _cast3 Unmanaged.reflection_pad1d_out_ttl
+
+reflection_pad1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad1d_tl = _cast2 Unmanaged.reflection_pad1d_tl
+
+reflection_pad1d_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad1d_backward_out_tttl = _cast4 Unmanaged.reflection_pad1d_backward_out_tttl
+
+reflection_pad1d_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad1d_backward_ttl = _cast3 Unmanaged.reflection_pad1d_backward_ttl
+
+reflection_pad2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad2d_out_ttl = _cast3 Unmanaged.reflection_pad2d_out_ttl
+
+reflection_pad2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad2d_tl = _cast2 Unmanaged.reflection_pad2d_tl
+
+reflection_pad2d_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad2d_backward_out_tttl = _cast4 Unmanaged.reflection_pad2d_backward_out_tttl
+
+reflection_pad2d_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad2d_backward_ttl = _cast3 Unmanaged.reflection_pad2d_backward_ttl
+
+reflection_pad3d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad3d_out_ttl = _cast3 Unmanaged.reflection_pad3d_out_ttl
+
+reflection_pad3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad3d_tl = _cast2 Unmanaged.reflection_pad3d_tl
+
+reflection_pad3d_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad3d_backward_out_tttl = _cast4 Unmanaged.reflection_pad3d_backward_out_tttl
+
+reflection_pad3d_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+reflection_pad3d_backward_ttl = _cast3 Unmanaged.reflection_pad3d_backward_ttl
+
+replication_pad1d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad1d_out_ttl = _cast3 Unmanaged.replication_pad1d_out_ttl
+
+replication_pad1d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad1d_tl = _cast2 Unmanaged.replication_pad1d_tl
+
+replication_pad1d_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad1d_backward_out_tttl = _cast4 Unmanaged.replication_pad1d_backward_out_tttl
+
+replication_pad1d_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad1d_backward_ttl = _cast3 Unmanaged.replication_pad1d_backward_ttl
+
+replication_pad2d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad2d_out_ttl = _cast3 Unmanaged.replication_pad2d_out_ttl
+
+replication_pad2d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad2d_tl = _cast2 Unmanaged.replication_pad2d_tl
+
+replication_pad2d_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad2d_backward_out_tttl = _cast4 Unmanaged.replication_pad2d_backward_out_tttl
+
+replication_pad2d_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad2d_backward_ttl = _cast3 Unmanaged.replication_pad2d_backward_ttl
+
+replication_pad3d_out_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad3d_out_ttl = _cast3 Unmanaged.replication_pad3d_out_ttl
+
+replication_pad3d_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad3d_tl = _cast2 Unmanaged.replication_pad3d_tl
+
+replication_pad3d_backward_out_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad3d_backward_out_tttl = _cast4 Unmanaged.replication_pad3d_backward_out_tttl
+
+replication_pad3d_backward_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+replication_pad3d_backward_ttl = _cast3 Unmanaged.replication_pad3d_backward_ttl
+
+_pad_circular_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_pad_circular_tl = _cast2 Unmanaged._pad_circular_tl
+
+_pad_enum_tlld
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_pad_enum_tlld = _cast4 Unmanaged._pad_enum_tlld
+
+_pad_enum_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_pad_enum_tll = _cast3 Unmanaged._pad_enum_tll
+
+pad_tlsd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+pad_tlsd = _cast4 Unmanaged.pad_tlsd
+
+pad_tls
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+pad_tls = _cast3 Unmanaged.pad_tls
+
+pad_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+pad_tl = _cast2 Unmanaged.pad_tl
+
+upsample_linear1d_tlba
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+upsample_linear1d_tlba = _cast4 Unmanaged.upsample_linear1d_tlba
+
+upsample_bilinear2d_tlba
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_tlba = _cast4 Unmanaged.upsample_bilinear2d_tlba
+
+_upsample_bilinear2d_aa_tlba
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_tlba = _cast4 Unmanaged._upsample_bilinear2d_aa_tlba
+
+upsample_trilinear3d_tlba
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+upsample_trilinear3d_tlba = _cast4 Unmanaged.upsample_trilinear3d_tlba
+
+upsample_bicubic2d_tlba
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_tlba = _cast4 Unmanaged.upsample_bicubic2d_tlba
+
+_upsample_bicubic2d_aa_tlba
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_upsample_bicubic2d_aa_tlba = _cast4 Unmanaged._upsample_bicubic2d_aa_tlba
+
+upsample_nearest1d_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+upsample_nearest1d_tla = _cast3 Unmanaged.upsample_nearest1d_tla
+
+_upsample_nearest_exact1d_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact1d_tla = _cast3 Unmanaged._upsample_nearest_exact1d_tla
+
+upsample_nearest2d_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+upsample_nearest2d_tla = _cast3 Unmanaged.upsample_nearest2d_tla
+
+_upsample_nearest_exact2d_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact2d_tla = _cast3 Unmanaged._upsample_nearest_exact2d_tla
+
+upsample_nearest3d_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+upsample_nearest3d_tla = _cast3 Unmanaged.upsample_nearest3d_tla
+
+_upsample_nearest_exact3d_tla
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr (StdVector CDouble)
+  -> IO (ForeignPtr Tensor)
+_upsample_nearest_exact3d_tla = _cast3 Unmanaged._upsample_nearest_exact3d_tla
+
+upsample_linear1d_out_ttlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_linear1d_out_ttlbd = _cast5 Unmanaged.upsample_linear1d_out_ttlbd
+
+upsample_linear1d_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_linear1d_out_ttlb = _cast4 Unmanaged.upsample_linear1d_out_ttlb
+
+upsample_linear1d_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> 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
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_linear1d_backward_out_ttllb = _cast5 Unmanaged.upsample_linear1d_backward_out_ttllb
+
+upsample_linear1d_backward_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_linear1d_backward_tllb = _cast4 Unmanaged.upsample_linear1d_backward_tllb
+
+upsample_bilinear2d_out_ttlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_out_ttlbdd = _cast6 Unmanaged.upsample_bilinear2d_out_ttlbdd
+
+upsample_bilinear2d_out_ttlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_out_ttlbd = _cast5 Unmanaged.upsample_bilinear2d_out_ttlbd
+
+upsample_bilinear2d_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_out_ttlb = _cast4 Unmanaged.upsample_bilinear2d_out_ttlb
+
+upsample_bilinear2d_tlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_tlbdd = _cast5 Unmanaged.upsample_bilinear2d_tlbdd
+
+upsample_bilinear2d_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_tlb = _cast3 Unmanaged.upsample_bilinear2d_tlb
+
+upsample_bilinear2d_backward_out_ttllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> 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_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bilinear2d_backward_tllb = _cast4 Unmanaged.upsample_bilinear2d_backward_tllb
+
+_upsample_bilinear2d_aa_out_ttlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_out_ttlbdd = _cast6 Unmanaged._upsample_bilinear2d_aa_out_ttlbdd
+
+_upsample_bilinear2d_aa_out_ttlbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_out_ttlbd = _cast5 Unmanaged._upsample_bilinear2d_aa_out_ttlbd
+
+_upsample_bilinear2d_aa_out_ttlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_out_ttlb = _cast4 Unmanaged._upsample_bilinear2d_aa_out_ttlb
+
+_upsample_bilinear2d_aa_tlbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_tlbdd = _cast5 Unmanaged._upsample_bilinear2d_aa_tlbdd
+
+-- _upsample_bilinear2d_aa_tlbd
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr IntArray
+--   -> CBool
+--   -> CDouble
+--   -> IO (ForeignPtr Tensor)
+-- _upsample_bilinear2d_aa_tlbd = _cast4 Unmanaged._upsample_bilinear2d_aa_tlbd
+
+_upsample_bilinear2d_aa_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_tlb = _cast3 Unmanaged._upsample_bilinear2d_aa_tlb
+
+_upsample_bilinear2d_aa_backward_out_ttllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_backward_out_ttllbdd = _cast7 Unmanaged._upsample_bilinear2d_aa_backward_out_ttllbdd
+
+_upsample_bilinear2d_aa_backward_out_ttllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_backward_out_ttllbd = _cast6 Unmanaged._upsample_bilinear2d_aa_backward_out_ttllbd
+
+_upsample_bilinear2d_aa_backward_out_ttllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_backward_out_ttllb = _cast5 Unmanaged._upsample_bilinear2d_aa_backward_out_ttllb
+
+_upsample_bilinear2d_aa_backward_tllbdd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_backward_tllbdd = _cast6 Unmanaged._upsample_bilinear2d_aa_backward_tllbdd
+
+_upsample_bilinear2d_aa_backward_tllbd
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_backward_tllbd = _cast5 Unmanaged._upsample_bilinear2d_aa_backward_tllbd
+
+_upsample_bilinear2d_aa_backward_tllb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_upsample_bilinear2d_aa_backward_tllb = _cast4 Unmanaged._upsample_bilinear2d_aa_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_tlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+upsample_bicubic2d_tlb = _cast3 Unmanaged.upsample_bicubic2d_tlb
+
diff --git a/src/Torch/Internal/Managed/Optim.hs b/src/Torch/Internal/Managed/Optim.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Optim.hs
@@ -0,0 +1,150 @@
+{-# LANGUAGE DataKinds #-}
+module Torch.Internal.Managed.Optim where
+
+import Foreign
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign.ForeignPtr.Unsafe
+import Torch.Internal.Cast
+import Torch.Internal.Class
+import Torch.Internal.Objects
+import Torch.Internal.Type
+import qualified Torch.Internal.Unmanaged.Optim as Unmanaged
+import Control.Concurrent.MVar (MVar(..), newEmptyMVar, putMVar, takeMVar)
+
+-- optimizerWithAdam
+--   :: CDouble
+--   -> CDouble
+--   -> CDouble
+--   -> CDouble
+--   -> CDouble
+--   -> CBool
+--   -> ForeignPtr TensorList
+--   -> (ForeignPtr TensorList -> IO (ForeignPtr Tensor))
+--   -> Int
+--   -> IO (ForeignPtr TensorList)
+-- optimizerWithAdam adamLr adamBetas0 adamBetas1 adamEps adamWeightDecay adamAmsgrad initParams loss numIter = _cast2 (\i n -> Unmanaged.optimizerWithAdam adamLr adamBetas0 adamBetas1 adamEps adamWeightDecay adamAmsgrad i (trans loss) n) initParams numIter
+--   where
+--     trans :: (ForeignPtr TensorList -> IO (ForeignPtr Tensor)) -> Ptr TensorList -> IO (Ptr Tensor)
+--     trans func inputs = do
+--       inputs' <- newForeignPtr_ inputs
+--       ret <- func inputs'
+--       return $ unsafeForeignPtrToPtr ret
+
+adagrad
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Optimizer)
+adagrad = _cast6 Unmanaged.adagrad
+
+rmsprop
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Optimizer)
+rmsprop = _cast7 Unmanaged.rmsprop
+
+sgd
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Optimizer)
+sgd = _cast6 Unmanaged.sgd
+
+adam
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Optimizer)
+adam = _cast7 Unmanaged.adam
+
+adamw
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Optimizer)
+adamw = _cast7 Unmanaged.adamw
+
+lbfgs
+  :: CDouble
+  -> CInt
+  -> CInt
+  -> CDouble
+  -> CDouble
+  -> CInt
+  -> Maybe (ForeignPtr StdString)
+  -> ForeignPtr TensorList
+  -> IO (ForeignPtr Optimizer)
+lbfgs = _cast8 Unmanaged.lbfgs
+
+getParams :: ForeignPtr Optimizer -> IO (ForeignPtr TensorList) 
+getParams = _cast1 Unmanaged.getParams
+
+step :: ForeignPtr Optimizer -> (ForeignPtr TensorList -> IO (ForeignPtr Tensor)) -> IO (ForeignPtr Tensor)
+step optimizer loss = do
+  ref <- newEmptyMVar
+  ret <- cast1 (\opt -> Unmanaged.step opt (trans ref loss)) optimizer
+  v <- takeMVar ref
+  touchForeignPtr v
+  return ret
+  where
+    trans :: MVar (ForeignPtr Tensor) -> (ForeignPtr TensorList -> IO (ForeignPtr Tensor)) -> Ptr TensorList -> IO (Ptr Tensor)
+    trans ref func inputs = do
+      inputs' <- newForeignPtr_ inputs
+      ret <- func inputs'
+      putMVar ref ret
+      return $ unsafeForeignPtrToPtr ret
+
+stepWithGenerator
+  :: ForeignPtr Optimizer
+  -> ForeignPtr Generator
+  -> (ForeignPtr TensorList -> ForeignPtr Generator -> IO (ForeignPtr (StdTuple '(Tensor,Generator))))
+  -> IO (ForeignPtr (StdTuple '(Tensor,Generator)))
+stepWithGenerator optimizer generator loss = do
+  ref <- newEmptyMVar
+  ret <- cast2 (\opt gen -> Unmanaged.stepWithGenerator opt gen (trans ref loss)) optimizer generator
+  v <- takeMVar ref
+  touchForeignPtr v
+  return ret
+  where
+    trans
+      :: MVar (ForeignPtr (StdTuple '(Tensor,Generator)))
+      -> (ForeignPtr TensorList -> ForeignPtr Generator -> IO (ForeignPtr (StdTuple '(Tensor,Generator))))
+      -> Ptr TensorList
+      -> Ptr Generator
+      -> IO (Ptr (StdTuple '(Tensor,Generator)))
+    trans ref func inputs generator = do
+      inputs' <- newForeignPtr_ inputs
+      generator' <- newForeignPtr_ generator
+      ret <- func inputs' generator'
+      putMVar ref ret
+      return $ unsafeForeignPtrToPtr ret
+
+
+unsafeStep :: ForeignPtr Optimizer -> ForeignPtr Tensor -> IO (ForeignPtr TensorList)
+unsafeStep = _cast2 Unmanaged.unsafeStep
+
+save :: ForeignPtr Optimizer -> ForeignPtr StdString -> IO ()
+save = _cast2 Unmanaged.save
+
+load :: ForeignPtr Optimizer -> ForeignPtr StdString -> IO ()
+load = _cast2 Unmanaged.load
diff --git a/src/Torch/Internal/Managed/Serialize.hs b/src/Torch/Internal/Managed/Serialize.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Serialize.hs
@@ -0,0 +1,23 @@
+
+module Torch.Internal.Managed.Serialize where
+
+import Foreign.ForeignPtr
+
+import qualified Torch.Internal.Unmanaged.Serialize as Unmanaged
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+
+save :: ForeignPtr TensorList -> FilePath -> IO ()
+save = _cast2 Unmanaged.save
+
+load :: FilePath -> IO (ForeignPtr TensorList)
+load = _cast1 Unmanaged.load
+
+pickleSave :: ForeignPtr IValue -> FilePath -> IO ()
+pickleSave = _cast2 Unmanaged.pickleSave
+
+pickleLoad :: FilePath -> IO (ForeignPtr IValue)
+pickleLoad = _cast1 Unmanaged.pickleLoad
diff --git a/src/Torch/Internal/Managed/TensorFactories.hs b/src/Torch/Internal/Managed/TensorFactories.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/TensorFactories.hs
@@ -0,0 +1,1283 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Managed.TensorFactories where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.TensorFactories as Unmanaged
+
+
+_cudnn_init_dropout_state_dblo
+  :: CDouble
+  -> CBool
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_cudnn_init_dropout_state_dblo = _cast4 Unmanaged._cudnn_init_dropout_state_dblo
+
+arange_so
+  :: ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+arange_so = _cast2 Unmanaged.arange_so
+
+arange_s
+  :: ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+arange_s = _cast1 Unmanaged.arange_s
+
+arange_sso
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+arange_sso = _cast3 Unmanaged.arange_sso
+
+arange_ss
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+arange_ss = _cast2 Unmanaged.arange_ss
+
+arange_ssso
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+arange_ssso = _cast4 Unmanaged.arange_ssso
+
+arange_sss
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+arange_sss = _cast3 Unmanaged.arange_sss
+
+bartlett_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+bartlett_window_lo = _cast2 Unmanaged.bartlett_window_lo
+
+bartlett_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+bartlett_window_l = _cast1 Unmanaged.bartlett_window_l
+
+bartlett_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+bartlett_window_lbo = _cast3 Unmanaged.bartlett_window_lbo
+
+bartlett_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+bartlett_window_lb = _cast2 Unmanaged.bartlett_window_lb
+
+blackman_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+blackman_window_lo = _cast2 Unmanaged.blackman_window_lo
+
+blackman_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+blackman_window_l = _cast1 Unmanaged.blackman_window_l
+
+blackman_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+blackman_window_lbo = _cast3 Unmanaged.blackman_window_lbo
+
+blackman_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+blackman_window_lb = _cast2 Unmanaged.blackman_window_lb
+
+empty_lNoM
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_lNoM = _cast4 Unmanaged.empty_lNoM
+
+empty_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+empty_lNo = _cast3 Unmanaged.empty_lNo
+
+empty_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+empty_lN = _cast2 Unmanaged.empty_lN
+
+empty_loM
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_loM = _cast3 Unmanaged.empty_loM
+
+empty_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+empty_lo = _cast2 Unmanaged.empty_lo
+
+empty_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+empty_l = _cast1 Unmanaged.empty_l
+
+_empty_affine_quantized_lodlM
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> CDouble
+  -> Int64
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_lodlM = _cast5 Unmanaged._empty_affine_quantized_lodlM
+
+_empty_affine_quantized_lodl
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> CDouble
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_lodl = _cast4 Unmanaged._empty_affine_quantized_lodl
+
+_empty_affine_quantized_lod
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_lod = _cast3 Unmanaged._empty_affine_quantized_lod
+
+_empty_affine_quantized_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_lo = _cast2 Unmanaged._empty_affine_quantized_lo
+
+_empty_affine_quantized_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_empty_affine_quantized_l = _cast1 Unmanaged._empty_affine_quantized_l
+
+_empty_per_channel_affine_quantized_lttloM
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_empty_per_channel_affine_quantized_lttloM = _cast6 Unmanaged._empty_per_channel_affine_quantized_lttloM
+
+_empty_per_channel_affine_quantized_lttlo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_empty_per_channel_affine_quantized_lttlo = _cast5 Unmanaged._empty_per_channel_affine_quantized_lttlo
+
+_empty_per_channel_affine_quantized_lttl
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+_empty_per_channel_affine_quantized_lttl = _cast4 Unmanaged._empty_per_channel_affine_quantized_lttl
+
+empty_quantized_ltoM
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_quantized_ltoM = _cast4 Unmanaged.empty_quantized_ltoM
+
+empty_quantized_lto
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+empty_quantized_lto = _cast3 Unmanaged.empty_quantized_lto
+
+empty_quantized_lt
+  :: ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+empty_quantized_lt = _cast2 Unmanaged.empty_quantized_lt
+
+empty_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+empty_like_toM = _cast3 Unmanaged.empty_like_toM
+
+empty_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+empty_strided_llo = _cast3 Unmanaged.empty_strided_llo
+
+empty_strided_ll
+  :: ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+empty_strided_ll = _cast2 Unmanaged.empty_strided_ll
+
+eye_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+eye_lo = _cast2 Unmanaged.eye_lo
+
+eye_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+eye_l = _cast1 Unmanaged.eye_l
+
+eye_llo
+  :: Int64
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+eye_llo = _cast3 Unmanaged.eye_llo
+
+eye_ll
+  :: Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+eye_ll = _cast2 Unmanaged.eye_ll
+
+full_lsNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+full_lsNo = _cast4 Unmanaged.full_lsNo
+
+full_lsN
+  :: ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+full_lsN = _cast3 Unmanaged.full_lsN
+
+full_lso
+  :: ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+full_lso = _cast3 Unmanaged.full_lso
+
+full_ls
+  :: ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+full_ls = _cast2 Unmanaged.full_ls
+
+full_like_tsoM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+full_like_tsoM = _cast4 Unmanaged.full_like_tsoM
+
+full_like_tso
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+from_file_sblo = _cast4 Unmanaged.from_file_sblo
+
+from_file_sbl
+  :: ForeignPtr StdString
+  -> CBool
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+from_file_sbl = _cast3 Unmanaged.from_file_sbl
+
+from_file_sb
+  :: ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+from_file_sb = _cast2 Unmanaged.from_file_sb
+
+from_file_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+from_file_s = _cast1 Unmanaged.from_file_s
+
+hann_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hann_window_lo = _cast2 Unmanaged.hann_window_lo
+
+hann_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+hann_window_l = _cast1 Unmanaged.hann_window_l
+
+hann_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hann_window_lbo = _cast3 Unmanaged.hann_window_lbo
+
+hann_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+hann_window_lb = _cast2 Unmanaged.hann_window_lb
+
+hamming_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hamming_window_lo = _cast2 Unmanaged.hamming_window_lo
+
+hamming_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+hamming_window_l = _cast1 Unmanaged.hamming_window_l
+
+hamming_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbo = _cast3 Unmanaged.hamming_window_lbo
+
+hamming_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+hamming_window_lb = _cast2 Unmanaged.hamming_window_lb
+
+hamming_window_lbdo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbdo = _cast4 Unmanaged.hamming_window_lbdo
+
+hamming_window_lbd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbd = _cast3 Unmanaged.hamming_window_lbd
+
+hamming_window_lbddo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbddo = _cast5 Unmanaged.hamming_window_lbddo
+
+hamming_window_lbdd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+hamming_window_lbdd = _cast4 Unmanaged.hamming_window_lbdd
+
+kaiser_window_lo
+  :: Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lo = _cast2 Unmanaged.kaiser_window_lo
+
+kaiser_window_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+kaiser_window_l = _cast1 Unmanaged.kaiser_window_l
+
+kaiser_window_lbo
+  :: Int64
+  -> CBool
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lbo = _cast3 Unmanaged.kaiser_window_lbo
+
+kaiser_window_lb
+  :: Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lb = _cast2 Unmanaged.kaiser_window_lb
+
+kaiser_window_lbdo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lbdo = _cast4 Unmanaged.kaiser_window_lbdo
+
+kaiser_window_lbd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+kaiser_window_lbd = _cast3 Unmanaged.kaiser_window_lbd
+
+linspace_sslo
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+linspace_sslo = _cast4 Unmanaged.linspace_sslo
+
+linspace_ssl
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+linspace_ssl = _cast3 Unmanaged.linspace_ssl
+
+logspace_ssldo
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+logspace_ssldo = _cast5 Unmanaged.logspace_ssldo
+
+logspace_ssld
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+logspace_ssld = _cast4 Unmanaged.logspace_ssld
+
+logspace_ssl
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+logspace_ssl = _cast3 Unmanaged.logspace_ssl
+
+ones_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+ones_lNo = _cast3 Unmanaged.ones_lNo
+
+ones_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+ones_lN = _cast2 Unmanaged.ones_lN
+
+ones_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+ones_lo = _cast2 Unmanaged.ones_lo
+
+ones_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+ones_l = _cast1 Unmanaged.ones_l
+
+ones_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+ones_like_toM = _cast3 Unmanaged.ones_like_toM
+
+ones_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> IO (ForeignPtr Tensor)
+scalar_tensor_so = _cast2 Unmanaged.scalar_tensor_so
+
+scalar_tensor_s
+  :: ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+scalar_tensor_s = _cast1 Unmanaged.scalar_tensor_s
+
+rand_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+rand_lNo = _cast3 Unmanaged.rand_lNo
+
+rand_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+rand_lN = _cast2 Unmanaged.rand_lN
+
+rand_lGNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+rand_lGNo = _cast4 Unmanaged.rand_lGNo
+
+rand_lGN
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+rand_lGN = _cast3 Unmanaged.rand_lGN
+
+rand_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+rand_lo = _cast2 Unmanaged.rand_lo
+
+rand_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+rand_l = _cast1 Unmanaged.rand_l
+
+rand_lGo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+rand_lGo = _cast3 Unmanaged.rand_lGo
+
+rand_lG
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+rand_lG = _cast2 Unmanaged.rand_lG
+
+rand_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+rand_like_toM = _cast3 Unmanaged.rand_like_toM
+
+rand_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randint_llo = _cast3 Unmanaged.randint_llo
+
+randint_ll
+  :: Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randint_ll = _cast2 Unmanaged.randint_ll
+
+randint_llGo
+  :: Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randint_llGo = _cast4 Unmanaged.randint_llGo
+
+randint_llG
+  :: Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randint_llG = _cast3 Unmanaged.randint_llG
+
+randint_lllo
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randint_lllo = _cast4 Unmanaged.randint_lllo
+
+randint_lll
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randint_lll = _cast3 Unmanaged.randint_lll
+
+randint_lllGo
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randint_lllGo = _cast5 Unmanaged.randint_lllGo
+
+randint_lllG
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randint_lllG = _cast4 Unmanaged.randint_lllG
+
+randint_like_tloM
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randint_like_tloM = _cast4 Unmanaged.randint_like_tloM
+
+randint_like_tlo
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randint_like_tlloM = _cast5 Unmanaged.randint_like_tlloM
+
+randint_like_tllo
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> IO (ForeignPtr Tensor)
+randn_lo = _cast2 Unmanaged.randn_lo
+
+randn_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+randn_l = _cast1 Unmanaged.randn_l
+
+randn_lGo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randn_lGo = _cast3 Unmanaged.randn_lGo
+
+randn_lG
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randn_lG = _cast2 Unmanaged.randn_lG
+
+randn_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randn_lNo = _cast3 Unmanaged.randn_lNo
+
+randn_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+randn_lN = _cast2 Unmanaged.randn_lN
+
+randn_lGNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randn_lGNo = _cast4 Unmanaged.randn_lGNo
+
+randn_lGN
+  :: ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+randn_lGN = _cast3 Unmanaged.randn_lGN
+
+randn_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+randn_like_toM = _cast3 Unmanaged.randn_like_toM
+
+randn_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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
+  -> IO (ForeignPtr Tensor)
+randperm_lo = _cast2 Unmanaged.randperm_lo
+
+randperm_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+randperm_l = _cast1 Unmanaged.randperm_l
+
+randperm_lGo
+  :: Int64
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+randperm_lGo = _cast3 Unmanaged.randperm_lGo
+
+randperm_lG
+  :: Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+randperm_lG = _cast2 Unmanaged.randperm_lG
+
+range_ssso
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+range_ssso = _cast4 Unmanaged.range_ssso
+
+range_sss
+  :: ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+range_sss = _cast3 Unmanaged.range_sss
+
+zeros_lNo
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+zeros_lNo = _cast3 Unmanaged.zeros_lNo
+
+zeros_lN
+  :: ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+zeros_lN = _cast2 Unmanaged.zeros_lN
+
+_efficientzerotensor_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_efficientzerotensor_lo = _cast2 Unmanaged._efficientzerotensor_lo
+
+_efficientzerotensor_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_efficientzerotensor_l = _cast1 Unmanaged._efficientzerotensor_l
+
+zeros_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+zeros_lo = _cast2 Unmanaged.zeros_lo
+
+zeros_l
+  :: ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+zeros_l = _cast1 Unmanaged.zeros_l
+
+zeros_like_toM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+zeros_like_toM = _cast3 Unmanaged.zeros_like_toM
+
+zeros_like_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> 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_compressed_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_compressed_tensor_tttlo = _cast5 Unmanaged.sparse_compressed_tensor_tttlo
+
+sparse_csr_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_csr_tensor_tttlo = _cast5 Unmanaged.sparse_csr_tensor_tttlo
+
+sparse_csc_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_csc_tensor_tttlo = _cast5 Unmanaged.sparse_csc_tensor_tttlo
+
+sparse_bsr_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_bsr_tensor_tttlo = _cast5 Unmanaged.sparse_bsr_tensor_tttlo
+
+sparse_bsc_tensor_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_bsc_tensor_tttlo = _cast5 Unmanaged.sparse_bsc_tensor_tttlo
+
+sparse_compressed_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_compressed_tensor_ttto = _cast4 Unmanaged.sparse_compressed_tensor_ttto
+
+sparse_csr_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_csr_tensor_ttto = _cast4 Unmanaged.sparse_csr_tensor_ttto
+
+sparse_csc_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_csc_tensor_ttto = _cast4 Unmanaged.sparse_csc_tensor_ttto
+
+sparse_bsr_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_bsr_tensor_ttto = _cast4 Unmanaged.sparse_bsr_tensor_ttto
+
+sparse_bsc_tensor_ttto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_bsc_tensor_ttto = _cast4 Unmanaged.sparse_bsc_tensor_ttto
+
+_sparse_compressed_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_compressed_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_compressed_tensor_unsafe_tttlo
+
+_sparse_compressed_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_compressed_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_compressed_tensor_unsafe_tttl
+
+_sparse_csr_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_csr_tensor_unsafe_tttlo
+
+_sparse_csr_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_csr_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_csr_tensor_unsafe_tttl
+
+_sparse_csc_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_csc_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_csc_tensor_unsafe_tttlo
+
+_sparse_csc_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_csc_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_csc_tensor_unsafe_tttl
+
+_sparse_bsr_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_bsr_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_bsr_tensor_unsafe_tttlo
+
+_sparse_bsr_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_bsr_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_bsr_tensor_unsafe_tttl
+
+_sparse_bsc_tensor_unsafe_tttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_bsc_tensor_unsafe_tttlo = _cast5 Unmanaged._sparse_bsc_tensor_unsafe_tttlo
+
+_sparse_bsc_tensor_unsafe_tttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_bsc_tensor_unsafe_tttl = _cast4 Unmanaged._sparse_bsc_tensor_unsafe_tttl
+
+sparse_coo_tensor_lo
+  :: ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_lo = _cast2 Unmanaged.sparse_coo_tensor_lo
+
+sparse_coo_tensor_tto
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_tto = _cast3 Unmanaged.sparse_coo_tensor_tto
+
+sparse_coo_tensor_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_tt = _cast2 Unmanaged.sparse_coo_tensor_tt
+
+sparse_coo_tensor_ttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_ttlo = _cast4 Unmanaged.sparse_coo_tensor_ttlo
+
+sparse_coo_tensor_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+sparse_coo_tensor_ttl = _cast3 Unmanaged.sparse_coo_tensor_ttl
+
+_sparse_coo_tensor_unsafe_ttlo
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_unsafe_ttlo = _cast4 Unmanaged._sparse_coo_tensor_unsafe_ttlo
+
+_sparse_coo_tensor_unsafe_ttl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_unsafe_ttl = _cast3 Unmanaged._sparse_coo_tensor_unsafe_ttl
+
+_sparse_coo_tensor_with_dims_lllo
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_with_dims_lllo = _cast4 Unmanaged._sparse_coo_tensor_with_dims_lllo
+
+_sparse_coo_tensor_with_dims_and_tensors_llltto
+  :: Int64
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_sparse_coo_tensor_with_dims_and_tensors_llltto = _cast6 Unmanaged._sparse_coo_tensor_with_dims_and_tensors_llltto
+
+_to_copy_tobM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> CBool
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+_to_copy_tobM = _cast4 Unmanaged._to_copy_tobM
+
+_to_copy_tob
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+_to_copy_tob = _cast3 Unmanaged._to_copy_tob
+
+_to_copy_to
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+_to_copy_to = _cast2 Unmanaged._to_copy_to
+
+_to_copy_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+_to_copy_t = _cast1 Unmanaged._to_copy_t
+
+tril_indices_lllo
+  :: Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+tril_indices_lllo = _cast4 Unmanaged.tril_indices_lllo
+
+tril_indices_lll
+  :: Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tril_indices_lll = _cast3 Unmanaged.tril_indices_lll
+
+tril_indices_ll
+  :: Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tril_indices_ll = _cast2 Unmanaged.tril_indices_ll
+
+triu_indices_lllo
+  :: Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+triu_indices_lllo = _cast4 Unmanaged.triu_indices_lllo
+
+triu_indices_lll
+  :: Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triu_indices_lll = _cast3 Unmanaged.triu_indices_lll
+
+triu_indices_ll
+  :: Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+triu_indices_ll = _cast2 Unmanaged.triu_indices_ll
+
+normal_ddlGo
+  :: CDouble
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+normal_ddlGo = _cast5 Unmanaged.normal_ddlGo
+
+normal_ddlG
+  :: CDouble
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+normal_ddlG = _cast4 Unmanaged.normal_ddlG
+
+normal_ddl
+  :: CDouble
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+normal_ddl = _cast3 Unmanaged.normal_ddl
+
+fft_fftfreq_ldo
+  :: Int64
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+fft_fftfreq_ldo = _cast3 Unmanaged.fft_fftfreq_ldo
+
+fft_fftfreq_ld
+  :: Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+fft_fftfreq_ld = _cast2 Unmanaged.fft_fftfreq_ld
+
+fft_fftfreq_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+fft_fftfreq_l = _cast1 Unmanaged.fft_fftfreq_l
+
+fft_rfftfreq_ldo
+  :: Int64
+  -> CDouble
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+fft_rfftfreq_ldo = _cast3 Unmanaged.fft_rfftfreq_ldo
+
+fft_rfftfreq_ld
+  :: Int64
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+fft_rfftfreq_ld = _cast2 Unmanaged.fft_rfftfreq_ld
+
+fft_rfftfreq_l
+  :: Int64
+  -> IO (ForeignPtr Tensor)
+fft_rfftfreq_l = _cast1 Unmanaged.fft_rfftfreq_l
+
diff --git a/src/Torch/Internal/Managed/Type/C10Dict.hs b/src/Torch/Internal/Managed/Type/C10Dict.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/C10Dict.hs
@@ -0,0 +1,48 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.C10Dict where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.C10Dict as Unmanaged
+
+import Control.Monad (forM)
+
+
+newC10Dict :: ForeignPtr IValue -> ForeignPtr IValue -> IO (ForeignPtr (C10Dict '(IValue,IValue)))
+newC10Dict = _cast2 Unmanaged.newC10Dict
+
+c10Dict_empty :: ForeignPtr (C10Dict '(IValue,IValue)) -> IO (CBool)
+c10Dict_empty = _cast1 Unmanaged.c10Dict_empty
+
+c10Dict_size :: ForeignPtr (C10Dict '(IValue,IValue)) -> IO (CSize)
+c10Dict_size = _cast1 Unmanaged.c10Dict_size
+
+c10Dict_at :: ForeignPtr (C10Dict '(IValue,IValue)) -> ForeignPtr IValue -> IO (ForeignPtr IValue)
+c10Dict_at = _cast2 Unmanaged.c10Dict_at
+
+c10Dict_insert :: ForeignPtr (C10Dict '(IValue,IValue)) -> ForeignPtr IValue -> ForeignPtr IValue -> IO ()
+c10Dict_insert = _cast3 Unmanaged.c10Dict_insert
+
+c10Dict_toList :: ForeignPtr (C10Dict '(IValue,IValue)) -> IO [(ForeignPtr IValue,ForeignPtr IValue)]
+c10Dict_toList obj = withForeignPtr obj $ \obj' -> do
+  v <- Unmanaged.c10Dict_toList obj' :: IO [(Ptr IValue,Ptr IValue)]
+  forM v $ \(a,b) -> do
+    a' <- uncast a return 
+    b' <- uncast b return
+    return (a',b')
diff --git a/src/Torch/Internal/Managed/Type/C10List.hs b/src/Torch/Internal/Managed/Type/C10List.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/C10List.hs
@@ -0,0 +1,118 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.C10List where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.C10List as Unmanaged
+
+
+
+newC10ListIValue :: ForeignPtr IValue -> IO (ForeignPtr (C10List IValue))
+newC10ListIValue elem = _cast1 Unmanaged.newC10ListIValue elem
+
+newC10ListTensor :: IO (ForeignPtr (C10List Tensor))
+newC10ListTensor = _cast0 Unmanaged.newC10ListTensor
+
+newC10ListOptionalTensor :: IO (ForeignPtr (C10List (C10Optional Tensor)))
+newC10ListOptionalTensor = _cast0 Unmanaged.newC10ListOptionalTensor
+
+newC10ListDouble :: IO (ForeignPtr (C10List CDouble))
+newC10ListDouble = _cast0 Unmanaged.newC10ListDouble
+
+newC10ListInt :: IO (ForeignPtr (C10List Int64))
+newC10ListInt = _cast0 Unmanaged.newC10ListInt
+
+newC10ListBool :: IO (ForeignPtr (C10List CBool))
+newC10ListBool = _cast0 Unmanaged.newC10ListBool
+
+
+
+
+
+c10ListIValue_empty :: ForeignPtr (C10List IValue) -> IO (CBool)
+c10ListIValue_empty = _cast1 Unmanaged.c10ListIValue_empty
+
+c10ListTensor_empty :: ForeignPtr (C10List Tensor) -> IO (CBool)
+c10ListTensor_empty = _cast1 Unmanaged.c10ListTensor_empty
+
+c10ListOptionalTensor_empty :: ForeignPtr (C10List (C10Optional Tensor)) -> IO (CBool)
+c10ListOptionalTensor_empty = _cast1 Unmanaged.c10ListOptionalTensor_empty
+
+c10ListDouble_empty :: ForeignPtr (C10List CDouble) -> IO (CBool)
+c10ListDouble_empty = _cast1 Unmanaged.c10ListDouble_empty
+
+c10ListInt_empty :: ForeignPtr (C10List Int64) -> IO (CBool)
+c10ListInt_empty = _cast1 Unmanaged.c10ListInt_empty
+
+c10ListBool_empty :: ForeignPtr (C10List CBool) -> IO (CBool)
+c10ListBool_empty = _cast1 Unmanaged.c10ListBool_empty
+
+c10ListIValue_size :: ForeignPtr (C10List IValue) -> IO (CSize)
+c10ListIValue_size = _cast1 Unmanaged.c10ListIValue_size
+
+c10ListTensor_size :: ForeignPtr (C10List Tensor) -> IO (CSize)
+c10ListTensor_size = _cast1 Unmanaged.c10ListTensor_size
+
+c10ListOptionalTensor_size :: ForeignPtr (C10List (C10Optional Tensor)) -> IO (CSize)
+c10ListOptionalTensor_size = _cast1 Unmanaged.c10ListOptionalTensor_size
+
+c10ListDouble_size :: ForeignPtr (C10List CDouble) -> IO (CSize)
+c10ListDouble_size = _cast1 Unmanaged.c10ListDouble_size
+
+c10ListInt_size :: ForeignPtr (C10List Int64) -> IO (CSize)
+c10ListInt_size = _cast1 Unmanaged.c10ListInt_size
+
+c10ListBool_size :: ForeignPtr (C10List CBool) -> IO (CSize)
+c10ListBool_size = _cast1 Unmanaged.c10ListBool_size
+
+c10ListIValue_at :: ForeignPtr (C10List IValue) -> CSize -> IO (ForeignPtr IValue)
+c10ListIValue_at = _cast2 Unmanaged.c10ListIValue_at
+
+c10ListTensor_at :: ForeignPtr (C10List Tensor) -> CSize -> IO (ForeignPtr Tensor)
+c10ListTensor_at = _cast2 Unmanaged.c10ListTensor_at
+
+c10ListOptionalTensor_at :: ForeignPtr (C10List (C10Optional Tensor)) -> CSize -> IO (ForeignPtr Tensor)
+c10ListOptionalTensor_at = _cast2 Unmanaged.c10ListOptionalTensor_at
+
+c10ListDouble_at :: ForeignPtr (C10List CDouble) -> CSize -> IO CDouble
+c10ListDouble_at = _cast2 Unmanaged.c10ListDouble_at
+
+c10ListInt_at :: ForeignPtr (C10List Int64) -> CSize -> IO Int64
+c10ListInt_at = _cast2 Unmanaged.c10ListInt_at
+
+c10ListBool_at :: ForeignPtr (C10List CBool) -> CSize -> IO CBool
+c10ListBool_at = _cast2 Unmanaged.c10ListBool_at
+
+c10ListIValue_push_back :: ForeignPtr (C10List IValue) -> ForeignPtr IValue -> IO ()
+c10ListIValue_push_back = _cast2 Unmanaged.c10ListIValue_push_back
+
+c10ListTensor_push_back :: ForeignPtr (C10List Tensor) -> ForeignPtr Tensor -> IO ()
+c10ListTensor_push_back = _cast2 Unmanaged.c10ListTensor_push_back
+
+c10ListOptionalTensor_push_back :: ForeignPtr (C10List (C10Optional Tensor)) -> ForeignPtr Tensor -> IO ()
+c10ListOptionalTensor_push_back = _cast2 Unmanaged.c10ListOptionalTensor_push_back
+
+c10ListDouble_push_back :: ForeignPtr (C10List CDouble) -> CDouble -> IO ()
+c10ListDouble_push_back = _cast2 Unmanaged.c10ListDouble_push_back
+
+c10ListInt_push_back :: ForeignPtr (C10List Int64) -> Int64 -> IO ()
+c10ListInt_push_back = _cast2 Unmanaged.c10ListInt_push_back
+
+c10ListBool_push_back :: ForeignPtr (C10List CBool) -> CBool -> IO ()
+c10ListBool_push_back = _cast2 Unmanaged.c10ListBool_push_back
diff --git a/src/Torch/Internal/Managed/Type/C10Tuple.hs b/src/Torch/Internal/Managed/Type/C10Tuple.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/C10Tuple.hs
@@ -0,0 +1,49 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.C10Tuple where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.C10Tuple as Unmanaged
+
+
+
+newC10Tuple
+  :: IO (ForeignPtr (C10Ptr IVTuple))
+newC10Tuple = _cast0 Unmanaged.newC10Tuple
+
+newC10Tuple_tuple
+  :: ForeignPtr IValueList
+  -> IO (ForeignPtr (C10Ptr IVTuple))
+newC10Tuple_tuple  = _cast1 Unmanaged.newC10Tuple_tuple
+
+c10Tuple_empty
+  :: ForeignPtr (C10Ptr IVTuple)
+  -> IO (CBool)
+c10Tuple_empty = _cast1 Unmanaged.c10Tuple_empty
+
+c10Tuple_size
+  :: ForeignPtr (C10Ptr IVTuple)
+  -> IO (CSize)
+c10Tuple_size = _cast1 Unmanaged.c10Tuple_size
+
+c10Tuple_at
+  :: ForeignPtr (C10Ptr IVTuple)
+  -> CSize
+  -> IO (ForeignPtr IValue)
+c10Tuple_at = _cast2 Unmanaged.c10Tuple_at
diff --git a/src/Torch/Internal/Managed/Type/Context.hs b/src/Torch/Internal/Managed/Type/Context.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Context.hs
@@ -0,0 +1,82 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Context where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.Generator as Unmanaged
+import qualified Torch.Internal.Unmanaged.Type.Context as Unmanaged
+
+
+
+
+
+
+
+
+
+init
+  :: IO (())
+init = _cast0 Unmanaged.init
+
+hasCUDA
+  :: IO (CBool)
+hasCUDA = _cast0 Unmanaged.hasCUDA
+
+hasHIP
+  :: IO (CBool)
+hasHIP = _cast0 Unmanaged.hasHIP
+
+hasXLA
+  :: IO (CBool)
+hasXLA = _cast0 Unmanaged.hasXLA
+
+getNumGPUs
+  :: IO (CSize)
+getNumGPUs = _cast0 Unmanaged.getNumGPUs
+
+hasOpenMP
+  :: IO (CBool)
+hasOpenMP = _cast0 Unmanaged.hasOpenMP
+
+hasMKL
+  :: IO (CBool)
+hasMKL = _cast0 Unmanaged.hasMKL
+
+hasLAPACK
+  :: IO (CBool)
+hasLAPACK = _cast0 Unmanaged.hasLAPACK
+
+hasMAGMA
+  :: IO (CBool)
+hasMAGMA = _cast0 Unmanaged.hasMAGMA
+
+hasMKLDNN
+  :: IO (CBool)
+hasMKLDNN = _cast0 Unmanaged.hasMKLDNN
+
+manual_seed_L
+  :: Word64
+  -> IO (())
+manual_seed_L = _cast1 Unmanaged.manual_seed_L
+
+get_manual_seed
+  :: IO (Word64)
+get_manual_seed = do
+  g <- Unmanaged.getDefaultCPUGenerator
+  Unmanaged.generator_current_seed g
diff --git a/src/Torch/Internal/Managed/Type/Dimname.hs b/src/Torch/Internal/Managed/Type/Dimname.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Dimname.hs
@@ -0,0 +1,66 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Dimname where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Dimname as Unmanaged
+
+
+
+
+
+newDimname_n
+  :: ForeignPtr Dimname
+  -> IO (ForeignPtr Dimname)
+newDimname_n = _cast1 Unmanaged.newDimname_n
+
+dimname_symbol
+  :: ForeignPtr Dimname
+  -> IO (ForeignPtr Symbol)
+dimname_symbol = _cast1 Unmanaged.dimname_symbol
+
+dimname_isBasic
+  :: ForeignPtr Dimname
+  -> IO (CBool)
+dimname_isBasic = _cast1 Unmanaged.dimname_isBasic
+
+dimname_isWildcard
+  :: ForeignPtr Dimname
+  -> IO (CBool)
+dimname_isWildcard = _cast1 Unmanaged.dimname_isWildcard
+
+dimname_matches_n
+  :: ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> IO (CBool)
+dimname_matches_n = _cast2 Unmanaged.dimname_matches_n
+
+fromSymbol_s
+  :: ForeignPtr Symbol
+  -> IO (ForeignPtr Dimname)
+fromSymbol_s = _cast1 Unmanaged.fromSymbol_s
+
+wildcard
+  :: IO (ForeignPtr Dimname)
+wildcard = _cast0 Unmanaged.wildcard
+
+isValidName_s
+  :: ForeignPtr StdString
+  -> IO (CBool)
+isValidName_s = _cast1 Unmanaged.isValidName_s
+
diff --git a/src/Torch/Internal/Managed/Type/DimnameList.hs b/src/Torch/Internal/Managed/Type/DimnameList.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/DimnameList.hs
@@ -0,0 +1,52 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.DimnameList where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.DimnameList as Unmanaged
+
+
+
+
+
+newDimnameList
+  :: IO (ForeignPtr DimnameList)
+newDimnameList = _cast0 Unmanaged.newDimnameList
+
+dimnameList_empty
+  :: ForeignPtr DimnameList
+  -> IO (CBool)
+dimnameList_empty = _cast1 Unmanaged.dimnameList_empty
+
+dimnameList_size
+  :: ForeignPtr DimnameList
+  -> IO (CSize)
+dimnameList_size = _cast1 Unmanaged.dimnameList_size
+
+dimnameList_at_s
+  :: ForeignPtr DimnameList
+  -> CSize
+  -> IO (ForeignPtr Dimname)
+dimnameList_at_s = _cast2 Unmanaged.dimnameList_at_s
+
+dimnameList_push_back_n
+  :: ForeignPtr DimnameList
+  -> ForeignPtr Dimname
+  -> IO (())
+dimnameList_push_back_n = _cast2 Unmanaged.dimnameList_push_back_n
+
diff --git a/src/Torch/Internal/Managed/Type/Extra.hs b/src/Torch/Internal/Managed/Type/Extra.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Extra.hs
@@ -0,0 +1,96 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Extra where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.Extra as Unmanaged
+
+tensor_assign1_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO ()
+tensor_assign1_l  = _cast3 Unmanaged.tensor_assign1_l
+
+tensor_assign2_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO ()
+tensor_assign2_l = _cast4 Unmanaged.tensor_assign2_l
+
+tensor_assign1_d
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CDouble
+  -> IO ()
+tensor_assign1_d = _cast3 Unmanaged.tensor_assign1_d
+
+tensor_assign2_d
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO ()
+tensor_assign2_d = _cast4 Unmanaged.tensor_assign2_d
+
+tensor_assign1_t
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO ()
+tensor_assign1_t  = _cast3 Unmanaged.tensor_assign1_t
+
+tensor_assign2_t
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO ()
+tensor_assign2_t = _cast4 Unmanaged.tensor_assign2_t
+
+tensor_names
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr DimnameList)
+tensor_names = _cast1 Unmanaged.tensor_names
+
+tensor_to_device
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_to_device = _cast2 Unmanaged.tensor_to_device
+
+new_empty_tensor
+  :: [Int]
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+new_empty_tensor = _cast2 Unmanaged.new_empty_tensor
+
+
+tensor_dim_unsafe
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_dim_unsafe = cast1 Unmanaged.tensor_dim_unsafe
+
+tensor_dim_c_unsafe
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_dim_c_unsafe = cast1 Unmanaged.tensor_dim_c_unsafe
+                                                  
diff --git a/src/Torch/Internal/Managed/Type/Generator.hs b/src/Torch/Internal/Managed/Type/Generator.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Generator.hs
@@ -0,0 +1,79 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Generator where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.Generator as Unmanaged
+
+
+
+newCUDAGenerator
+  :: Word16
+  -> IO (ForeignPtr Generator)
+newCUDAGenerator _device_index = _cast1 Unmanaged.newCUDAGenerator _device_index
+
+newCPUGenerator
+  :: Word64
+  -> IO (ForeignPtr Generator)
+newCPUGenerator _seed_in = _cast1 Unmanaged.newCPUGenerator _seed_in
+
+
+
+
+
+generator_set_current_seed
+  :: ForeignPtr Generator
+  -> Word64
+  -> IO ()
+generator_set_current_seed = _cast2 Unmanaged.generator_set_current_seed
+
+generator_current_seed
+  :: ForeignPtr Generator
+  -> IO (Word64)
+generator_current_seed = _cast1 Unmanaged.generator_current_seed
+
+generator_seed
+  :: ForeignPtr Generator
+  -> IO (Word64)
+generator_seed = _cast1 Unmanaged.generator_seed
+
+generator_clone
+  :: ForeignPtr Generator
+  -> IO (ForeignPtr Generator)
+generator_clone _obj = _cast1 Unmanaged.generator_clone _obj
+
+generator_get_device
+  :: ForeignPtr Generator
+  -> IO Int64
+generator_get_device _obj = _cast1 Unmanaged.generator_get_device _obj
+
+generator_is_cpu
+  :: ForeignPtr Generator
+  -> IO CBool
+generator_is_cpu _obj = _cast1 Unmanaged.generator_is_cpu _obj
+
+generator_is_cuda
+  :: ForeignPtr Generator
+  -> IO CBool
+generator_is_cuda _obj = _cast1 Unmanaged.generator_is_cuda _obj
+
+generator_is_hip
+  :: ForeignPtr Generator
+  -> IO CBool
+generator_is_hip _obj = _cast1 Unmanaged.generator_is_hip _obj
diff --git a/src/Torch/Internal/Managed/Type/IValue.hs b/src/Torch/Internal/Managed/Type/IValue.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/IValue.hs
@@ -0,0 +1,214 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+
+
+module Torch.Internal.Managed.Type.IValue where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.IValue as Unmanaged
+import Torch.Internal.Unmanaged.Type.IValue (IValueLike)
+
+instance IValueLike Double (ForeignPtr IValue) where
+  toIValue x = _cast1 (Unmanaged.toIValue :: CDouble -> IO (Ptr IValue)) x
+  fromIValue x = _cast1 (Unmanaged.fromIValue :: Ptr IValue -> IO CDouble) x
+
+instance IValueLike Int64 (ForeignPtr IValue) where
+  toIValue x = _cast1 (Unmanaged.toIValue :: Int64 -> IO (Ptr IValue)) x
+  fromIValue x = _cast1 (Unmanaged.fromIValue :: Ptr IValue -> IO Int64) x
+
+instance IValueLike Bool (ForeignPtr IValue) where
+  toIValue x = _cast1 (Unmanaged.toIValue :: CBool -> IO (Ptr IValue)) x
+  fromIValue x = _cast1 (Unmanaged.fromIValue :: Ptr IValue -> IO CBool) x
+
+--instance IValueLike (ForeignPtr StdString) (ForeignPtr IValue) where
+--  toIValue x = _cast1 (Unmanaged.toIValue :: Ptr StdString -> IO (Ptr IValue)) x
+--  fromIValue x = _cast1 (Unmanaged.fromIValue :: Ptr IValue -> IO (Ptr StdString)) x
+--instance IValueLike String (ForeignPtr IValue) where
+--  toIValue x = _cast1 (Unmanaged.toIValue :: CBool -> IO (Ptr IValue)) x
+--  fromIValue x = _cast1 (Unmanaged.fromIValue :: Ptr IValue -> IO CBool) x
+
+instance (CppObject a, IValueLike (Ptr a) (Ptr IValue)) => IValueLike (ForeignPtr a) (ForeignPtr IValue) where
+  toIValue x = _cast1 (Unmanaged.toIValue :: Ptr a -> IO (Ptr IValue)) x
+  fromIValue x = _cast1 (Unmanaged.fromIValue :: Ptr IValue -> IO (Ptr a)) x
+
+newIValue
+  :: IO (ForeignPtr IValue)
+newIValue  = _cast0 Unmanaged.newIValue
+
+iValue_isAliasOf_V
+  :: ForeignPtr IValue
+  -> ForeignPtr IValue
+  -> IO (CBool)
+iValue_isAliasOf_V = _cast2 Unmanaged.iValue_isAliasOf_V
+
+iValue_use_count
+  :: ForeignPtr IValue
+  -> IO (CSize)
+iValue_use_count = _cast1 Unmanaged.iValue_use_count
+
+iValue_swap_V
+  :: ForeignPtr IValue
+  -> ForeignPtr IValue
+  -> IO (())
+iValue_swap_V = _cast2 Unmanaged.iValue_swap_V
+
+iValue_isTensor
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isTensor = _cast1 Unmanaged.iValue_isTensor
+
+iValue_isBlob
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isBlob = _cast1 Unmanaged.iValue_isBlob
+
+iValue_isCapsule
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isCapsule = _cast1 Unmanaged.iValue_isCapsule
+
+iValue_isTuple
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isTuple = _cast1 Unmanaged.iValue_isTuple
+
+iValue_isDouble
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isDouble = _cast1 Unmanaged.iValue_isDouble
+
+iValue_isFuture
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isFuture = _cast1 Unmanaged.iValue_isFuture
+
+iValue_isInt
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isInt = _cast1 Unmanaged.iValue_isInt
+
+iValue_isIntList
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isIntList = _cast1 Unmanaged.iValue_isIntList
+
+iValue_isString
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isString = _cast1 Unmanaged.iValue_isString
+
+iValue_toStringRef
+  :: ForeignPtr IValue
+  -> IO (ForeignPtr StdString)
+iValue_toStringRef = _cast1 Unmanaged.iValue_toStringRef
+
+iValue_isDoubleList
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isDoubleList = _cast1 Unmanaged.iValue_isDoubleList
+
+iValue_isBool
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isBool = _cast1 Unmanaged.iValue_isBool
+
+iValue_isObject
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isObject = _cast1 Unmanaged.iValue_isObject
+
+iValue_isBoolList
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isBoolList = _cast1 Unmanaged.iValue_isBoolList
+
+iValue_isTensorList
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isTensorList = _cast1 Unmanaged.iValue_isTensorList
+
+iValue_isList
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isList = _cast1 Unmanaged.iValue_isList
+
+iValue_isGenericDict
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isGenericDict = _cast1 Unmanaged.iValue_isGenericDict
+
+iValue_isNone
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isNone = _cast1 Unmanaged.iValue_isNone
+
+iValue_toNone
+  :: ForeignPtr IValue
+  -> IO (ForeignPtr StdString)
+iValue_toNone = _cast1 Unmanaged.iValue_toNone
+
+iValue_isScalar
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isScalar = _cast1 Unmanaged.iValue_isScalar
+
+iValue_isDevice
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isDevice = _cast1 Unmanaged.iValue_isDevice
+
+iValue_toScalarType
+  :: ForeignPtr IValue
+  -> IO (ScalarType)
+iValue_toScalarType = _cast1 Unmanaged.iValue_toScalarType
+
+iValue_toLayout
+  :: ForeignPtr IValue
+  -> IO (Layout)
+iValue_toLayout = _cast1 Unmanaged.iValue_toLayout
+
+iValue_toMemoryFormat
+  :: ForeignPtr IValue
+  -> IO (MemoryFormat)
+iValue_toMemoryFormat = _cast1 Unmanaged.iValue_toMemoryFormat
+
+iValue_toQScheme
+  :: ForeignPtr IValue
+  -> IO (QScheme)
+iValue_toQScheme = _cast1 Unmanaged.iValue_toQScheme
+
+iValue_tagKind
+  :: ForeignPtr IValue
+  -> IO (ForeignPtr StdString)
+iValue_tagKind = _cast1 Unmanaged.iValue_tagKind
+
+iValue_isSameIdentity_V
+  :: ForeignPtr IValue
+  -> ForeignPtr IValue
+  -> IO (CBool)
+iValue_isSameIdentity_V = _cast2 Unmanaged.iValue_isSameIdentity_V
+
+iValue_isPtrType
+  :: ForeignPtr IValue
+  -> IO (CBool)
+iValue_isPtrType = _cast1 Unmanaged.iValue_isPtrType
+
diff --git a/src/Torch/Internal/Managed/Type/IValueList.hs b/src/Torch/Internal/Managed/Type/IValueList.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/IValueList.hs
@@ -0,0 +1,57 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.IValueList where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.IValueList as Unmanaged
+
+
+
+newIValueList
+  :: IO (ForeignPtr IValueList)
+newIValueList = _cast0 Unmanaged.newIValueList
+
+
+
+
+
+ivalueList_empty
+  :: ForeignPtr IValueList
+  -> IO (CBool)
+ivalueList_empty = _cast1 Unmanaged.ivalueList_empty
+
+ivalueList_size
+  :: ForeignPtr IValueList
+  -> IO (CSize)
+ivalueList_size = _cast1 Unmanaged.ivalueList_size
+
+ivalueList_at
+  :: ForeignPtr IValueList
+  -> CSize
+  -> IO (ForeignPtr IValue)
+ivalueList_at = _cast2 Unmanaged.ivalueList_at
+
+ivalueList_push_back
+  :: ForeignPtr IValueList
+  -> ForeignPtr IValue
+  -> IO (())
+ivalueList_push_back = _cast2 Unmanaged.ivalueList_push_back
+
+
+
diff --git a/src/Torch/Internal/Managed/Type/IntArray.hs b/src/Torch/Internal/Managed/Type/IntArray.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/IntArray.hs
@@ -0,0 +1,61 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.IntArray where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.IntArray as Unmanaged
+
+
+
+
+
+newIntArray
+  :: IO (ForeignPtr IntArray)
+newIntArray = _cast0 Unmanaged.newIntArray
+
+intArray_empty
+  :: ForeignPtr IntArray
+  -> IO (CBool)
+intArray_empty = _cast1 Unmanaged.intArray_empty
+
+intArray_size
+  :: ForeignPtr IntArray
+  -> IO (CSize)
+intArray_size = _cast1 Unmanaged.intArray_size
+
+intArray_at_s
+  :: ForeignPtr IntArray
+  -> CSize
+  -> IO (Int64)
+intArray_at_s = _cast2 Unmanaged.intArray_at_s
+
+intArray_push_back_l
+  :: ForeignPtr IntArray
+  -> Int64
+  -> IO (())
+intArray_push_back_l = _cast2 Unmanaged.intArray_push_back_l
+
+intArray_fromList
+  :: ForeignPtr IntArray
+  -> [Int64]
+  -> IO (())
+intArray_fromList = _cast2 Unmanaged.intArray_fromList
+
+intArray_toList
+  :: ForeignPtr IntArray -> IO [Int64]
+intArray_toList = _cast1 Unmanaged.intArray_toList
diff --git a/src/Torch/Internal/Managed/Type/Module.hs b/src/Torch/Internal/Managed/Type/Module.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Module.hs
@@ -0,0 +1,159 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+
+
+module Torch.Internal.Managed.Type.Module where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Foreign.ForeignPtr.Unsafe
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import Control.Monad(forM)
+import Control.Concurrent.MVar (MVar(..), newEmptyMVar, putMVar, takeMVar)
+
+import qualified Torch.Internal.Unmanaged.Type.Module as Unmanaged
+
+newModule :: ForeignPtr StdString -> IO (ForeignPtr Module)
+newModule = _cast1 Unmanaged.newModule
+
+save :: ForeignPtr Module -> FilePath -> IO ()
+save = _cast2 Unmanaged.save
+
+load :: FilePath -> IO (ForeignPtr Module)
+load = _cast1 Unmanaged.load
+
+forward :: ForeignPtr Module -> (ForeignPtr (StdVector IValue)) -> IO (ForeignPtr IValue)
+forward = _cast2 Unmanaged.forward
+
+registerParameter :: ForeignPtr Module -> ForeignPtr StdString -> ForeignPtr Tensor -> CBool -> IO ()
+registerParameter = _cast4 Unmanaged.registerParameter
+
+registerModule :: ForeignPtr Module -> ForeignPtr StdString -> ForeignPtr Module -> IO ()
+registerModule = _cast3 Unmanaged.registerModule
+
+train :: ForeignPtr Module -> CBool -> IO ()
+train = _cast2 Unmanaged.train
+
+runMethod :: ForeignPtr Module -> ForeignPtr StdString -> ForeignPtr (C10List IValue) -> IO (Ptr IValue)
+runMethod = _cast3 Unmanaged.runMethod
+
+runMethod1 :: ForeignPtr Module -> ForeignPtr StdString -> ForeignPtr IValue -> IO (Ptr IValue)
+runMethod1 = _cast3 Unmanaged.runMethod1
+
+getParameters :: ForeignPtr Module -> IO (ForeignPtr TensorList)
+getParameters = _cast1 Unmanaged.getParameters
+
+setParameters :: ForeignPtr Module -> ForeignPtr TensorList -> IO ()
+setParameters = _cast2 Unmanaged.setParameters
+
+getNamedParameters :: ForeignPtr Module -> IO [(ForeignPtr StdString,ForeignPtr Tensor)]
+getNamedParameters obj = withForeignPtr obj $ \obj' -> do
+  v <- Unmanaged.getNamedParameters obj'
+  forM v $ \(a,b) -> do
+    a' <- uncast a return 
+    b' <- uncast b return
+    return (a',b')
+
+getNamedBuffers :: ForeignPtr Module -> IO [(ForeignPtr StdString,ForeignPtr Tensor)]
+getNamedBuffers obj = withForeignPtr obj $ \obj' -> do
+  v <- Unmanaged.getNamedBuffers obj'
+  forM v $ \(a,b) -> do
+    a' <- uncast a return 
+    b' <- uncast b return
+    return (a',b')
+
+getNamedAttributes :: ForeignPtr Module -> IO [(ForeignPtr StdString,ForeignPtr IValue)]
+getNamedAttributes obj = withForeignPtr obj $ \obj' -> do
+  v <- Unmanaged.getNamedAttributes obj'
+  forM v $ \(a,b) -> do
+    a' <- uncast a return 
+    b' <- uncast b return
+    return (a',b')
+
+getNamedModules :: ForeignPtr Module -> IO [(ForeignPtr StdString,ForeignPtr Module)]
+getNamedModules obj = withForeignPtr obj $ \obj' -> do
+  v <- Unmanaged.getNamedModules obj'
+  forM v $ \(a,b) -> do
+    a' <- uncast a return 
+    b' <- uncast b return
+    return (a',b')
+
+getNamedChildren :: ForeignPtr Module -> IO [(ForeignPtr StdString,ForeignPtr Module)]
+getNamedChildren obj = withForeignPtr obj $ \obj' -> do
+  v <- Unmanaged.getNamedChildren obj'
+  forM v $ \(a,b) -> do
+    a' <- uncast a return 
+    b' <- uncast b return
+    return (a',b')
+
+toDevice :: ForeignPtr Module -> DeviceType -> Int16 -> IO ()
+toDevice = _cast3 Unmanaged.toDevice
+
+clone :: ForeignPtr Module -> IO (ForeignPtr Module)
+clone = _cast1 Unmanaged.clone
+
+define :: ForeignPtr Module -> ForeignPtr StdString -> IO ()
+define = _cast2 Unmanaged.define
+
+
+-- Note: Not to release "ForeignPtr TensorList" before calling trace, put the pointer to MVar, and touch the reference.
+trace :: String -> String -> (ForeignPtr TensorList -> IO (ForeignPtr TensorList)) -> ForeignPtr TensorList -> IO (ForeignPtr Module)
+trace moduleName functionName func inputs = do
+  ref <- newEmptyMVar
+  ret <- cast3 (\m f inps -> Unmanaged.trace m f (trans ref func) inps) moduleName functionName inputs
+  v <- takeMVar ref
+  touchForeignPtr v
+  return ret
+  where
+    trans :: MVar (ForeignPtr TensorList) -> (ForeignPtr TensorList -> IO (ForeignPtr TensorList)) -> Ptr TensorList -> IO (Ptr TensorList)
+    trans ref func inputs = do
+      inputs' <- fromPtr inputs
+      ret <- func inputs'
+      putMVar ref ret
+      return $ unsafeForeignPtrToPtr ret
+
+-- Note: Not to release "ForeignPtr TensorList" after calling trace, put the pointer to MVar, and touch the reference.
+traceAsGraph :: (ForeignPtr TensorList -> IO (ForeignPtr TensorList)) -> ForeignPtr TensorList -> IO (ForeignPtr (SharedPtr JitGraph))
+traceAsGraph func inputs = do
+  ref <- newEmptyMVar
+  ret <- cast1 (\inps -> Unmanaged.traceAsGraph (trans ref func) inps) inputs
+  v <- takeMVar ref
+  touchForeignPtr v
+  return ret
+  where
+    trans :: MVar (ForeignPtr TensorList) -> (ForeignPtr TensorList -> IO (ForeignPtr TensorList)) -> Ptr TensorList -> IO (Ptr TensorList)
+    trans ref func inputs = do
+      inputs' <- fromPtr inputs
+      ret <- func inputs'
+      putMVar ref ret
+      return $ unsafeForeignPtrToPtr ret
+
+printGraph :: ForeignPtr (SharedPtr JitGraph) -> IO (ForeignPtr StdString)
+printGraph graph = _cast1 Unmanaged.printGraph graph
+
+printOnnx :: ForeignPtr (SharedPtr JitGraph) -> IO (ForeignPtr StdString)
+printOnnx graph = _cast1 Unmanaged.printOnnx graph
+
+dumpToStr
+  :: ForeignPtr Module
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr StdString)
+dumpToStr = _cast4 Unmanaged.dumpToStr
diff --git a/src/Torch/Internal/Managed/Type/Scalar.hs b/src/Torch/Internal/Managed/Type/Scalar.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Scalar.hs
@@ -0,0 +1,50 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Scalar where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Scalar as Unmanaged
+
+
+
+
+
+newScalar
+  :: IO (ForeignPtr Scalar)
+newScalar = _cast0 Unmanaged.newScalar
+
+newScalar_i
+  :: CInt
+  -> IO (ForeignPtr Scalar)
+newScalar_i = _cast1 Unmanaged.newScalar_i
+
+newScalar_d
+  :: CDouble
+  -> IO (ForeignPtr Scalar)
+newScalar_d = _cast1 Unmanaged.newScalar_d
+
+newScalar_b
+  :: CBool
+  -> IO (ForeignPtr Scalar)
+newScalar_b = _cast1 Unmanaged.newScalar_b
+
+newScalar_f
+  :: CFloat
+  -> IO (ForeignPtr Scalar)
+newScalar_f = _cast1 Unmanaged.newScalar_f
+
diff --git a/src/Torch/Internal/Managed/Type/StdArray.hs b/src/Torch/Internal/Managed/Type/StdArray.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/StdArray.hs
@@ -0,0 +1,86 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.StdArray where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.StdArray as Unmanaged
+
+
+
+newStdArrayBool2
+  :: IO (ForeignPtr (StdArray '(CBool,2)))
+newStdArrayBool2 = _cast0 Unmanaged.newStdArrayBool2
+
+newStdArrayBool2_bb
+  :: CBool
+  -> CBool
+  -> IO (ForeignPtr (StdArray '(CBool,2)))
+newStdArrayBool2_bb = _cast2 Unmanaged.newStdArrayBool2_bb
+
+instance CppTuple2 (ForeignPtr (StdArray '(CBool,2))) where
+  type A (ForeignPtr (StdArray '(CBool,2))) = CBool
+  type B (ForeignPtr (StdArray '(CBool,2))) = CBool
+  get0 v = _cast1 (get0 :: Ptr (StdArray '(CBool,2)) -> IO CBool) v
+  get1 v = _cast1 (get1 :: Ptr (StdArray '(CBool,2)) -> IO CBool) v
+
+newStdArrayBool3
+  :: IO (ForeignPtr (StdArray '(CBool,3)))
+newStdArrayBool3 = _cast0 Unmanaged.newStdArrayBool3
+
+newStdArrayBool3_bbb
+  :: CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdArray '(CBool,3)))
+newStdArrayBool3_bbb = _cast3 Unmanaged.newStdArrayBool3_bbb
+
+instance CppTuple2 (ForeignPtr (StdArray '(CBool,3))) where
+  type A (ForeignPtr (StdArray '(CBool,3))) = CBool
+  type B (ForeignPtr (StdArray '(CBool,3))) = CBool
+  get0 v = _cast1 (get0 :: Ptr (StdArray '(CBool,3)) -> IO CBool) v
+  get1 v = _cast1 (get1 :: Ptr (StdArray '(CBool,3)) -> IO CBool) v
+
+instance CppTuple3 (ForeignPtr (StdArray '(CBool,3))) where
+  type C (ForeignPtr (StdArray '(CBool,3))) = CBool
+  get2 v = _cast1 (get2 :: Ptr (StdArray '(CBool,3)) -> IO CBool) v
+
+newStdArrayBool4
+  :: IO (ForeignPtr (StdArray '(CBool,4)))
+newStdArrayBool4 = _cast0 Unmanaged.newStdArrayBool4
+
+newStdArrayBool4_bbbb
+  :: CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdArray '(CBool,4)))
+newStdArrayBool4_bbbb = _cast4 Unmanaged.newStdArrayBool4_bbbb
+
+instance CppTuple2 (ForeignPtr (StdArray '(CBool,4))) where
+  type A (ForeignPtr (StdArray '(CBool,4))) = CBool
+  type B (ForeignPtr (StdArray '(CBool,4))) = CBool
+  get0 v = _cast1 (get0 :: Ptr (StdArray '(CBool,4)) -> IO CBool) v
+  get1 v = _cast1 (get1 :: Ptr (StdArray '(CBool,4)) -> IO CBool) v
+
+instance CppTuple3 (ForeignPtr (StdArray '(CBool,4))) where
+  type C (ForeignPtr (StdArray '(CBool,4))) = CBool
+  get2 v = _cast1 (get2 :: Ptr (StdArray '(CBool,4)) -> IO CBool) v
+
+instance CppTuple4 (ForeignPtr (StdArray '(CBool,4))) where
+  type D (ForeignPtr (StdArray '(CBool,4))) = CBool
+  get3 v = _cast1 (get3 :: Ptr (StdArray '(CBool,4)) -> IO CBool) v
diff --git a/src/Torch/Internal/Managed/Type/StdString.hs b/src/Torch/Internal/Managed/Type/StdString.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/StdString.hs
@@ -0,0 +1,41 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
+module Torch.Internal.Managed.Type.StdString where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.StdString as Unmanaged
+
+
+
+newStdString
+  :: IO (ForeignPtr StdString)
+newStdString = _cast0 Unmanaged.newStdString
+
+newStdString_s
+  :: String
+  -> IO (ForeignPtr StdString)
+newStdString_s str = _cast1 Unmanaged.newStdString_s str
+
+string_c_str
+  :: ForeignPtr StdString
+  -> IO String
+string_c_str str = _cast1 Unmanaged.string_c_str str
+
+instance Castable String (ForeignPtr StdString) where
+  cast str f = newStdString_s str >>= f
+  uncast xs f = string_c_str xs >>= f
diff --git a/src/Torch/Internal/Managed/Type/StdVector.hs b/src/Torch/Internal/Managed/Type/StdVector.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/StdVector.hs
@@ -0,0 +1,73 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.StdVector where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.StdVector as Unmanaged
+
+
+
+newStdVectorDouble :: IO (ForeignPtr (StdVector CDouble))
+newStdVectorDouble = _cast0 Unmanaged.newStdVectorDouble
+
+newStdVectorInt :: IO (ForeignPtr (StdVector Int64))
+newStdVectorInt = _cast0 Unmanaged.newStdVectorInt
+
+newStdVectorBool :: IO (ForeignPtr (StdVector CBool))
+newStdVectorBool = _cast0 Unmanaged.newStdVectorBool
+
+
+
+
+
+stdVectorDouble_empty :: ForeignPtr (StdVector CDouble) -> IO (CBool)
+stdVectorDouble_empty = _cast1 Unmanaged.stdVectorDouble_empty
+
+stdVectorInt_empty :: ForeignPtr (StdVector Int64) -> IO (CBool)
+stdVectorInt_empty = _cast1 Unmanaged.stdVectorInt_empty
+
+stdVectorBool_empty :: ForeignPtr (StdVector CBool) -> IO (CBool)
+stdVectorBool_empty = _cast1 Unmanaged.stdVectorBool_empty
+
+stdVectorDouble_size :: ForeignPtr (StdVector CDouble) -> IO (CSize)
+stdVectorDouble_size = _cast1 Unmanaged.stdVectorDouble_size
+
+stdVectorInt_size :: ForeignPtr (StdVector Int64) -> IO (CSize)
+stdVectorInt_size = _cast1 Unmanaged.stdVectorInt_size
+
+stdVectorBool_size :: ForeignPtr (StdVector CBool) -> IO (CSize)
+stdVectorBool_size = _cast1 Unmanaged.stdVectorBool_size
+
+stdVectorDouble_at :: ForeignPtr (StdVector CDouble) -> CSize -> IO CDouble
+stdVectorDouble_at = _cast2 Unmanaged.stdVectorDouble_at
+
+stdVectorInt_at :: ForeignPtr (StdVector Int64) -> CSize -> IO Int64
+stdVectorInt_at = _cast2 Unmanaged.stdVectorInt_at
+
+stdVectorBool_at :: ForeignPtr (StdVector CBool) -> CSize -> IO CBool
+stdVectorBool_at = _cast2 Unmanaged.stdVectorBool_at
+
+stdVectorDouble_push_back :: ForeignPtr (StdVector CDouble) -> CDouble -> IO ()
+stdVectorDouble_push_back = _cast2 Unmanaged.stdVectorDouble_push_back
+
+stdVectorInt_push_back :: ForeignPtr (StdVector Int64) -> Int64 -> IO ()
+stdVectorInt_push_back = _cast2 Unmanaged.stdVectorInt_push_back
+
+stdVectorBool_push_back :: ForeignPtr (StdVector CBool) -> CBool -> IO ()
+stdVectorBool_push_back = _cast2 Unmanaged.stdVectorBool_push_back
diff --git a/src/Torch/Internal/Managed/Type/Storage.hs b/src/Torch/Internal/Managed/Type/Storage.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Storage.hs
@@ -0,0 +1,30 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Storage where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Storage as Unmanaged
+
+
+
+
+
+newStorage
+  :: IO (ForeignPtr Storage)
+newStorage = _cast0 Unmanaged.newStorage
+
diff --git a/src/Torch/Internal/Managed/Type/Symbol.hs b/src/Torch/Internal/Managed/Type/Symbol.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Symbol.hs
@@ -0,0 +1,115 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Symbol where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Symbol as Unmanaged
+
+
+
+
+
+newSymbol
+  :: IO (ForeignPtr Symbol)
+newSymbol = _cast0 Unmanaged.newSymbol
+
+symbol_is_attr
+  :: ForeignPtr Symbol
+  -> IO (CBool)
+symbol_is_attr = _cast1 Unmanaged.symbol_is_attr
+
+symbol_is_aten
+  :: ForeignPtr Symbol
+  -> IO (CBool)
+symbol_is_aten = _cast1 Unmanaged.symbol_is_aten
+
+symbol_is_prim
+  :: ForeignPtr Symbol
+  -> IO (CBool)
+symbol_is_prim = _cast1 Unmanaged.symbol_is_prim
+
+symbol_is_onnx
+  :: ForeignPtr Symbol
+  -> IO (CBool)
+symbol_is_onnx = _cast1 Unmanaged.symbol_is_onnx
+
+symbol_is_user
+  :: ForeignPtr Symbol
+  -> IO (CBool)
+symbol_is_user = _cast1 Unmanaged.symbol_is_user
+
+symbol_is_caffe2
+  :: ForeignPtr Symbol
+  -> IO (CBool)
+symbol_is_caffe2 = _cast1 Unmanaged.symbol_is_caffe2
+
+symbol_is_dimname
+  :: ForeignPtr Symbol
+  -> IO (CBool)
+symbol_is_dimname = _cast1 Unmanaged.symbol_is_dimname
+
+symbol_toUnqualString
+  :: ForeignPtr Symbol
+  -> IO (ForeignPtr StdString)
+symbol_toUnqualString = _cast1 Unmanaged.symbol_toUnqualString
+
+symbol_toQualString
+  :: ForeignPtr Symbol
+  -> IO (ForeignPtr StdString)
+symbol_toQualString = _cast1 Unmanaged.symbol_toQualString
+
+symbol_toDisplayString
+  :: ForeignPtr Symbol
+  -> IO (ForeignPtr StdString)
+symbol_toDisplayString = _cast1 Unmanaged.symbol_toDisplayString
+
+attr_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Symbol)
+attr_s = _cast1 Unmanaged.attr_s
+
+aten_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Symbol)
+aten_s = _cast1 Unmanaged.aten_s
+
+onnx_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Symbol)
+onnx_s = _cast1 Unmanaged.onnx_s
+
+prim_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Symbol)
+prim_s = _cast1 Unmanaged.prim_s
+
+user_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Symbol)
+user_s = _cast1 Unmanaged.user_s
+
+caffe2_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Symbol)
+caffe2_s = _cast1 Unmanaged.caffe2_s
+
+dimname_s
+  :: ForeignPtr StdString
+  -> IO (ForeignPtr Symbol)
+dimname_s = _cast1 Unmanaged.dimname_s
+
diff --git a/src/Torch/Internal/Managed/Type/Tensor.hs b/src/Torch/Internal/Managed/Type/Tensor.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Tensor.hs
@@ -0,0 +1,11 @@
+
+module Torch.Internal.Managed.Type.Tensor
+ ( module Torch.Internal.Managed.Type.Tensor.Tensor0
+ , module Torch.Internal.Managed.Type.Tensor.Tensor1
+ , module Torch.Internal.Managed.Type.Tensor.Tensor2
+ , module Torch.Internal.Managed.Type.Tensor.Tensor3
+ ) where
+import Torch.Internal.Managed.Type.Tensor.Tensor0
+import Torch.Internal.Managed.Type.Tensor.Tensor1
+import Torch.Internal.Managed.Type.Tensor.Tensor2
+import Torch.Internal.Managed.Type.Tensor.Tensor3
diff --git a/src/Torch/Internal/Managed/Type/Tensor/Tensor0.hs b/src/Torch/Internal/Managed/Type/Tensor/Tensor0.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Tensor/Tensor0.hs
@@ -0,0 +1,1215 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Tensor.Tensor0 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Tensor.Tensor0 as Unmanaged
+
+
+
+
+
+newTensor
+  :: IO (ForeignPtr Tensor)
+newTensor = cast0 Unmanaged.newTensor
+
+newTensor_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+newTensor_t = cast1 Unmanaged.newTensor_t
+
+tensor___dispatch_contiguous
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___dispatch_contiguous = cast1 Unmanaged.tensor___dispatch_contiguous
+
+tensor_backward_tbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (())
+tensor_backward_tbb = cast4 Unmanaged.tensor_backward_tbb
+
+tensor_contiguous
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_contiguous = cast1 Unmanaged.tensor_contiguous
+
+tensor_cpu
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_cpu = cast1 Unmanaged.tensor_cpu
+
+tensor_cuda
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_cuda = cast1 Unmanaged.tensor_cuda
+
+tensor_data_ptr
+  :: ForeignPtr Tensor
+  -> IO (Ptr ())
+tensor_data_ptr = cast1 Unmanaged.tensor_data_ptr
+
+tensor_defined
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_defined = cast1 Unmanaged.tensor_defined
+
+tensor_dim
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_dim = cast1 Unmanaged.tensor_dim
+
+tensor_element_size
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_element_size = cast1 Unmanaged.tensor_element_size
+
+tensor_get_device
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_get_device = cast1 Unmanaged.tensor_get_device
+
+tensor_has_names
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_has_names = cast1 Unmanaged.tensor_has_names
+
+tensor_has_storage
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_has_storage = cast1 Unmanaged.tensor_has_storage
+
+tensor_hip
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_hip = cast1 Unmanaged.tensor_hip
+
+tensor_is_alias_of_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_alias_of_t = cast2 Unmanaged.tensor_is_alias_of_t
+
+tensor_is_contiguous
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_contiguous = cast1 Unmanaged.tensor_is_contiguous
+
+tensor_is_cuda
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_cuda = cast1 Unmanaged.tensor_is_cuda
+
+tensor_is_hip
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_hip = cast1 Unmanaged.tensor_is_hip
+
+tensor_is_meta
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_meta = cast1 Unmanaged.tensor_is_meta
+
+tensor_is_metal
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_metal = cast1 Unmanaged.tensor_is_metal
+
+tensor_is_mkldnn
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_mkldnn = cast1 Unmanaged.tensor_is_mkldnn
+
+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_is_quantized
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_quantized = cast1 Unmanaged.tensor_is_quantized
+
+tensor_is_same_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_same_t = cast2 Unmanaged.tensor_is_same_t
+
+tensor_is_sparse
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_sparse = cast1 Unmanaged.tensor_is_sparse
+
+tensor_is_vulkan
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_vulkan = cast1 Unmanaged.tensor_is_vulkan
+
+tensor_is_xpu
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_xpu = cast1 Unmanaged.tensor_is_xpu
+
+tensor_item_double
+  :: ForeignPtr Tensor
+  -> IO (CDouble)
+tensor_item_double = cast1 Unmanaged.tensor_item_double
+
+tensor_item_float
+  :: ForeignPtr Tensor
+  -> IO (CFloat)
+tensor_item_float = cast1 Unmanaged.tensor_item_float
+
+tensor_item_int64_t
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_item_int64_t = cast1 Unmanaged.tensor_item_int64_t
+
+tensor_itemsize
+  :: ForeignPtr Tensor
+  -> IO (CSize)
+tensor_itemsize = cast1 Unmanaged.tensor_itemsize
+
+tensor_layout
+  :: ForeignPtr Tensor
+  -> IO (Layout)
+tensor_layout = cast1 Unmanaged.tensor_layout
+
+tensor_metal
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_metal = cast1 Unmanaged.tensor_metal
+
+tensor_mutable_grad
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_mutable_grad = cast1 Unmanaged.tensor_mutable_grad
+
+tensor_nbytes
+  :: ForeignPtr Tensor
+  -> IO (CSize)
+tensor_nbytes = cast1 Unmanaged.tensor_nbytes
+
+tensor_ndimension
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_ndimension = cast1 Unmanaged.tensor_ndimension
+
+tensor_numel
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_numel = cast1 Unmanaged.tensor_numel
+
+tensor__imul__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (())
+tensor__imul__s = cast2 Unmanaged.tensor__imul__s
+
+tensor__imul__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+tensor__imul__t = cast2 Unmanaged.tensor__imul__t
+
+tensor__iadd__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (())
+tensor__iadd__s = cast2 Unmanaged.tensor__iadd__s
+
+tensor__iadd__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+tensor__iadd__t = cast2 Unmanaged.tensor__iadd__t
+
+tensor__isub__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (())
+tensor__isub__s = cast2 Unmanaged.tensor__isub__s
+
+tensor__isub__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+tensor__isub__t = cast2 Unmanaged.tensor__isub__t
+
+tensor__idiv__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (())
+tensor__idiv__s = cast2 Unmanaged.tensor__idiv__s
+
+tensor__idiv__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+tensor__idiv__t = cast2 Unmanaged.tensor__idiv__t
+
+tensor__assign__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__assign__t = cast2 Unmanaged.tensor__assign__t
+
+tensor__at__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor__at__s = cast2 Unmanaged.tensor__at__s
+
+tensor__at__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__at__t = cast2 Unmanaged.tensor__at__t
+
+tensor__at__l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor__at__l = cast2 Unmanaged.tensor__at__l
+
+tensor_options
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr TensorOptions)
+tensor_options = cast1 Unmanaged.tensor_options
+
+tensor_print
+  :: ForeignPtr Tensor
+  -> IO (())
+tensor_print = cast1 Unmanaged.tensor_print
+
+tensor_requires_grad
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_requires_grad = cast1 Unmanaged.tensor_requires_grad
+
+tensor_reset
+  :: ForeignPtr Tensor
+  -> IO (())
+tensor_reset = cast1 Unmanaged.tensor_reset
+
+tensor_resize__l
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_resize__l = cast2 Unmanaged.tensor_resize__l
+
+tensor_scalar_type
+  :: ForeignPtr Tensor
+  -> IO (ScalarType)
+tensor_scalar_type = cast1 Unmanaged.tensor_scalar_type
+
+tensor_set_requires_grad_b
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_set_requires_grad_b = cast2 Unmanaged.tensor_set_requires_grad_b
+
+tensor_size_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (Int64)
+tensor_size_l = cast2 Unmanaged.tensor_size_l
+
+tensor_sizes
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr IntArray)
+tensor_sizes = cast1 Unmanaged.tensor_sizes
+
+tensor_storage
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Storage)
+tensor_storage = cast1 Unmanaged.tensor_storage
+
+tensor_storage_offset
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_storage_offset = cast1 Unmanaged.tensor_storage_offset
+
+tensor_stride_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (Int64)
+tensor_stride_l = cast2 Unmanaged.tensor_stride_l
+
+tensor_strides
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr IntArray)
+tensor_strides = cast1 Unmanaged.tensor_strides
+
+tensor_to_Dsbb
+  :: ForeignPtr Tensor
+  -> DeviceType
+  -> ScalarType
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_to_Dsbb = cast5 Unmanaged.tensor_to_Dsbb
+
+tensor_to_sbb
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_to_sbb = cast4 Unmanaged.tensor_to_sbb
+
+tensor_to_tbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_to_tbb = cast4 Unmanaged.tensor_to_tbb
+
+tensor_to_obb
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_to_obb = cast4 Unmanaged.tensor_to_obb
+
+tensor_toBackend_B
+  :: ForeignPtr Tensor
+  -> Backend
+  -> IO (ForeignPtr Tensor)
+tensor_toBackend_B = cast2 Unmanaged.tensor_toBackend_B
+
+tensor_toString
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr StdString)
+tensor_toString = cast1 Unmanaged.tensor_toString
+
+tensor_toType_s
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_toType_s = cast2 Unmanaged.tensor_toType_s
+
+tensor_to_dense
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_to_dense = cast1 Unmanaged.tensor_to_dense
+
+tensor_to_mkldnn
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_to_mkldnn = cast1 Unmanaged.tensor_to_mkldnn
+
+tensor_use_count
+  :: ForeignPtr Tensor
+  -> IO (CSize)
+tensor_use_count = cast1 Unmanaged.tensor_use_count
+
+tensor_vulkan
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_vulkan = cast1 Unmanaged.tensor_vulkan
+
+tensor_weak_use_count
+  :: ForeignPtr Tensor
+  -> IO (CSize)
+tensor_weak_use_count = cast1 Unmanaged.tensor_weak_use_count
+
+tensor__backward_ltbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (())
+tensor__backward_ltbb = cast5 Unmanaged.tensor__backward_ltbb
+
+tensor_set_data_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (())
+tensor_set_data_t = cast2 Unmanaged.tensor_set_data_t
+
+tensor_data
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_data = cast1 Unmanaged.tensor_data
+
+tensor_is_leaf
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_leaf = cast1 Unmanaged.tensor_is_leaf
+
+tensor_output_nr
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_output_nr = cast1 Unmanaged.tensor_output_nr
+
+tensor__version
+  :: ForeignPtr Tensor
+  -> 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_retains_grad
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_retains_grad = cast1 Unmanaged.tensor_retains_grad
+
+tensor__fw_primal_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor__fw_primal_l = cast2 Unmanaged.tensor__fw_primal_l
+
+tensor_rename__N
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+tensor_rename__N = cast2 Unmanaged.tensor_rename__N
+
+tensor_rename_N
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+tensor_rename_N = cast2 Unmanaged.tensor_rename_N
+
+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
+  -> IO (ForeignPtr Tensor)
+tensor_align_as_t = cast2 Unmanaged.tensor_align_as_t
+
+tensor_refine_names_N
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+tensor_refine_names_N = cast2 Unmanaged.tensor_refine_names_N
+
+tensor_abs
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_abs = cast1 Unmanaged.tensor_abs
+
+tensor_abs_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_abs_ = cast1 Unmanaged.tensor_abs_
+
+tensor_absolute
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_absolute = cast1 Unmanaged.tensor_absolute
+
+tensor_absolute_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_absolute_ = cast1 Unmanaged.tensor_absolute_
+
+tensor_angle
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_angle = cast1 Unmanaged.tensor_angle
+
+tensor_sgn
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sgn = cast1 Unmanaged.tensor_sgn
+
+tensor_sgn_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sgn_ = cast1 Unmanaged.tensor_sgn_
+
+tensor_chalf_M
+  :: ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_chalf_M = cast2 Unmanaged.tensor_chalf_M
+
+tensor__conj
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__conj = cast1 Unmanaged.tensor__conj
+
+tensor_conj
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_conj = cast1 Unmanaged.tensor_conj
+
+tensor__conj_physical
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__conj_physical = cast1 Unmanaged.tensor__conj_physical
+
+tensor_conj_physical
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_conj_physical = cast1 Unmanaged.tensor_conj_physical
+
+tensor_conj_physical_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_conj_physical_ = cast1 Unmanaged.tensor_conj_physical_
+
+tensor_resolve_conj
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_resolve_conj = cast1 Unmanaged.tensor_resolve_conj
+
+tensor_resolve_neg
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_resolve_neg = cast1 Unmanaged.tensor_resolve_neg
+
+tensor__neg_view
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__neg_view = cast1 Unmanaged.tensor__neg_view
+
+tensor_acos
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_acos = cast1 Unmanaged.tensor_acos
+
+tensor_acos_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_acos_ = cast1 Unmanaged.tensor_acos_
+
+tensor_arccos
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arccos = cast1 Unmanaged.tensor_arccos
+
+tensor_arccos_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arccos_ = cast1 Unmanaged.tensor_arccos_
+
+tensor_add_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_add_ts = cast3 Unmanaged.tensor_add_ts
+
+tensor_add__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_add__ts = cast3 Unmanaged.tensor_add__ts
+
+tensor_add_ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_add_ss = cast3 Unmanaged.tensor_add_ss
+
+tensor_add__ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_add__ss = cast3 Unmanaged.tensor_add__ss
+
+tensor_addmv_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addmv_ttss = cast5 Unmanaged.tensor_addmv_ttss
+
+tensor_addmv__ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addmv__ttss = cast5 Unmanaged.tensor_addmv__ttss
+
+tensor_addr_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addr_ttss = cast5 Unmanaged.tensor_addr_ttss
+
+tensor_addr__ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addr__ttss = cast5 Unmanaged.tensor_addr__ttss
+
+tensor__is_all_true
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__is_all_true = cast1 Unmanaged.tensor__is_all_true
+
+tensor__is_any_true
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__is_any_true = cast1 Unmanaged.tensor__is_any_true
+
+tensor_all_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_all_lb = cast3 Unmanaged.tensor_all_lb
+
+tensor_all_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_all_nb = cast3 Unmanaged.tensor_all_nb
+
+tensor_allclose_tddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (CBool)
+tensor_allclose_tddb = cast5 Unmanaged.tensor_allclose_tddb
+
+tensor_any_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_any_lb = cast3 Unmanaged.tensor_any_lb
+
+tensor_any_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_any_nb = cast3 Unmanaged.tensor_any_nb
+
+tensor_argmax_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_argmax_lb = cast3 Unmanaged.tensor_argmax_lb
+
+tensor_argmin_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_argmin_lb = cast3 Unmanaged.tensor_argmin_lb
+
+tensor_acosh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_acosh = cast1 Unmanaged.tensor_acosh
+
+tensor_acosh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_acosh_ = cast1 Unmanaged.tensor_acosh_
+
+tensor_arccosh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arccosh = cast1 Unmanaged.tensor_arccosh
+
+tensor_arccosh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arccosh_ = cast1 Unmanaged.tensor_arccosh_
+
+tensor_asinh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_asinh = cast1 Unmanaged.tensor_asinh
+
+tensor_asinh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_asinh_ = cast1 Unmanaged.tensor_asinh_
+
+tensor_arcsinh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arcsinh = cast1 Unmanaged.tensor_arcsinh
+
+tensor_arcsinh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arcsinh_ = cast1 Unmanaged.tensor_arcsinh_
+
+tensor_atanh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_atanh = cast1 Unmanaged.tensor_atanh
+
+tensor_atanh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_atanh_ = cast1 Unmanaged.tensor_atanh_
+
+tensor_arctanh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arctanh = cast1 Unmanaged.tensor_arctanh
+
+tensor_arctanh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arctanh_ = cast1 Unmanaged.tensor_arctanh_
+
+tensor_as_strided_lll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_as_strided_lll = cast4 Unmanaged.tensor_as_strided_lll
+
+tensor_as_strided__lll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_as_strided__lll = cast4 Unmanaged.tensor_as_strided__lll
+
+tensor_asin
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_asin = cast1 Unmanaged.tensor_asin
+
+tensor_asin_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_asin_ = cast1 Unmanaged.tensor_asin_
+
+tensor_arcsin
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arcsin = cast1 Unmanaged.tensor_arcsin
+
+tensor_arcsin_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arcsin_ = cast1 Unmanaged.tensor_arcsin_
+
+tensor_atan
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_atan = cast1 Unmanaged.tensor_atan
+
+tensor_atan_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_atan_ = cast1 Unmanaged.tensor_atan_
+
+tensor_arctan
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arctan = cast1 Unmanaged.tensor_arctan
+
+tensor_arctan_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arctan_ = cast1 Unmanaged.tensor_arctan_
+
+tensor_baddbmm_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_baddbmm_ttss = cast5 Unmanaged.tensor_baddbmm_ttss
+
+tensor_baddbmm__ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_baddbmm__ttss = cast5 Unmanaged.tensor_baddbmm__ttss
+
+tensor_bernoulli_G
+  :: ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_bernoulli_G = cast2 Unmanaged.tensor_bernoulli_G
+
+tensor_bernoulli__tG
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_bernoulli__tG = cast3 Unmanaged.tensor_bernoulli__tG
+
+tensor_bernoulli__dG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_bernoulli__dG = cast3 Unmanaged.tensor_bernoulli__dG
+
+tensor_bernoulli_dG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_bernoulli_dG = cast3 Unmanaged.tensor_bernoulli_dG
+
+tensor_bincount_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_bincount_tl = cast3 Unmanaged.tensor_bincount_tl
+
+tensor_bitwise_not
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_not = cast1 Unmanaged.tensor_bitwise_not
+
+tensor_bitwise_not_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_not_ = cast1 Unmanaged.tensor_bitwise_not_
+
+tensor_copysign_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_copysign_t = cast2 Unmanaged.tensor_copysign_t
+
+tensor_copysign__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_copysign__t = cast2 Unmanaged.tensor_copysign__t
+
+tensor_copysign_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_copysign_s = cast2 Unmanaged.tensor_copysign_s
+
+tensor_copysign__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_copysign__s = cast2 Unmanaged.tensor_copysign__s
+
+tensor_logical_not
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logical_not = cast1 Unmanaged.tensor_logical_not
+
+tensor_logical_not_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logical_not_ = cast1 Unmanaged.tensor_logical_not_
+
+tensor_logical_xor_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logical_xor_t = cast2 Unmanaged.tensor_logical_xor_t
+
+tensor_logical_xor__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> 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
+  -> IO (ForeignPtr Tensor)
+tensor_bmm_t = cast2 Unmanaged.tensor_bmm_t
+
+tensor_broadcast_to_l
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_broadcast_to_l = cast2 Unmanaged.tensor_broadcast_to_l
+
+tensor_ceil
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ceil = cast1 Unmanaged.tensor_ceil
+
+tensor_ceil_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ceil_ = cast1 Unmanaged.tensor_ceil_
+
+tensor_unsafe_chunk_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_unsafe_chunk_ll = cast3 Unmanaged.tensor_unsafe_chunk_ll
+
+tensor_chunk_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_chunk_ll = cast3 Unmanaged.tensor_chunk_ll
+
+tensor_tensor_split_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_tensor_split_tl = cast3 Unmanaged.tensor_tensor_split_tl
+
+tensor_clamp_ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_ss = cast3 Unmanaged.tensor_clamp_ss
+
+tensor_clamp_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_tt = cast3 Unmanaged.tensor_clamp_tt
+
+tensor_clamp__ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_clamp__ss = cast3 Unmanaged.tensor_clamp__ss
+
+tensor_clamp__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_clamp__tt = cast3 Unmanaged.tensor_clamp__tt
+
+tensor_clamp_max_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_max_s = cast2 Unmanaged.tensor_clamp_max_s
+
+tensor_clamp_max_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_max_t = cast2 Unmanaged.tensor_clamp_max_t
+
+tensor_clamp_max__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_max__s = cast2 Unmanaged.tensor_clamp_max__s
+
+tensor_clamp_max__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_max__t = cast2 Unmanaged.tensor_clamp_max__t
+
+tensor_clamp_min_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_min_s = cast2 Unmanaged.tensor_clamp_min_s
+
+tensor_clamp_min_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_min_t = cast2 Unmanaged.tensor_clamp_min_t
+
+tensor_clamp_min__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_min__s = cast2 Unmanaged.tensor_clamp_min__s
+
+tensor_clamp_min__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_clamp_min__t = cast2 Unmanaged.tensor_clamp_min__t
+
+tensor_clip_ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_clip_ss = cast3 Unmanaged.tensor_clip_ss
+
+tensor_clip_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_clip_tt = cast3 Unmanaged.tensor_clip_tt
+
+tensor_clip__ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_clip__ss = cast3 Unmanaged.tensor_clip__ss
+
+tensor_clip__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_clip__tt = cast3 Unmanaged.tensor_clip__tt
+
+tensor_contiguous_M
+  :: ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_contiguous_M = cast2 Unmanaged.tensor_contiguous_M
+
+tensor_copy__tb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_copy__tb = cast3 Unmanaged.tensor_copy__tb
+
+tensor_cos
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_cos = cast1 Unmanaged.tensor_cos
+
+tensor_cos_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_cos_ = cast1 Unmanaged.tensor_cos_
+
+tensor_cosh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_cosh = cast1 Unmanaged.tensor_cosh
+
+tensor_cosh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_cosh_ = cast1 Unmanaged.tensor_cosh_
+
+tensor_cov_ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_cov_ltt = cast4 Unmanaged.tensor_cov_ltt
+
+tensor_corrcoef
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_corrcoef = cast1 Unmanaged.tensor_corrcoef
+
+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
+
diff --git a/src/Torch/Internal/Managed/Type/Tensor/Tensor1.hs b/src/Torch/Internal/Managed/Type/Tensor/Tensor1.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Tensor/Tensor1.hs
@@ -0,0 +1,1308 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Tensor.Tensor1 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Tensor.Tensor1 as Unmanaged
+
+
+
+
+
+tensor_cummin_n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_cummin_n = cast2 Unmanaged.tensor_cummin_n
+
+tensor_cumprod_ls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_cumprod_ls = cast3 Unmanaged.tensor_cumprod_ls
+
+tensor_cumprod__ls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_cumprod__ls = cast3 Unmanaged.tensor_cumprod__ls
+
+tensor_cumprod_ns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_cumprod_ns = cast3 Unmanaged.tensor_cumprod_ns
+
+tensor_cumprod__ns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_cumprod__ns = cast3 Unmanaged.tensor_cumprod__ns
+
+tensor_cumsum_ls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_cumsum_ls = cast3 Unmanaged.tensor_cumsum_ls
+
+tensor_cumsum__ls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_cumsum__ls = cast3 Unmanaged.tensor_cumsum__ls
+
+tensor_cumsum_ns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_cumsum_ns = cast3 Unmanaged.tensor_cumsum_ns
+
+tensor_cumsum__ns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_cumsum__ns = cast3 Unmanaged.tensor_cumsum__ns
+
+tensor_diag_embed_lll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_diag_embed_lll = cast4 Unmanaged.tensor_diag_embed_lll
+
+tensor_diagflat_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_diagflat_l = cast2 Unmanaged.tensor_diagflat_l
+
+tensor_diagonal_lll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> 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
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_fill_diagonal__sb = cast3 Unmanaged.tensor_fill_diagonal__sb
+
+tensor_diff_lltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_diff_lltt = cast5 Unmanaged.tensor_diff_lltt
+
+tensor_div_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_div_t = cast2 Unmanaged.tensor_div_t
+
+tensor_div__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_div__t = cast2 Unmanaged.tensor_div__t
+
+tensor_div_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_div_ts = cast3 Unmanaged.tensor_div_ts
+
+tensor_div__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_div__ts = cast3 Unmanaged.tensor_div__ts
+
+tensor_div_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_div_s = cast2 Unmanaged.tensor_div_s
+
+tensor_div__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_div__s = cast2 Unmanaged.tensor_div__s
+
+tensor_div_ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_div_ss = cast3 Unmanaged.tensor_div_ss
+
+tensor_div__ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_div__ss = cast3 Unmanaged.tensor_div__ss
+
+tensor_divide_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_divide_t = cast2 Unmanaged.tensor_divide_t
+
+tensor_divide__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_divide__t = cast2 Unmanaged.tensor_divide__t
+
+tensor_divide_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_divide_s = cast2 Unmanaged.tensor_divide_s
+
+tensor_divide__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_divide__s = cast2 Unmanaged.tensor_divide__s
+
+tensor_divide_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_divide_ts = cast3 Unmanaged.tensor_divide_ts
+
+tensor_divide__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_divide__ts = cast3 Unmanaged.tensor_divide__ts
+
+tensor_divide_ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_divide_ss = cast3 Unmanaged.tensor_divide_ss
+
+tensor_divide__ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_divide__ss = cast3 Unmanaged.tensor_divide__ss
+
+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_dot_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_dot_t = cast2 Unmanaged.tensor_dot_t
+
+tensor_vdot_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_vdot_t = cast2 Unmanaged.tensor_vdot_t
+
+tensor_new_empty_lo
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+tensor_new_empty_lo = cast3 Unmanaged.tensor_new_empty_lo
+
+tensor_new_empty_strided_llo
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+tensor_new_empty_strided_llo = cast4 Unmanaged.tensor_new_empty_strided_llo
+
+tensor_new_full_lso
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr Scalar
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+tensor_new_full_lso = cast4 Unmanaged.tensor_new_full_lso
+
+tensor_new_zeros_lo
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+tensor_new_zeros_lo = cast3 Unmanaged.tensor_new_zeros_lo
+
+tensor_new_ones_lo
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr TensorOptions
+  -> IO (ForeignPtr Tensor)
+tensor_new_ones_lo = cast3 Unmanaged.tensor_new_ones_lo
+
+tensor_resize__lM
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_resize__lM = cast3 Unmanaged.tensor_resize__lM
+
+tensor_erf
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_erf = cast1 Unmanaged.tensor_erf
+
+tensor_erf_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_erf_ = cast1 Unmanaged.tensor_erf_
+
+tensor_erfc
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_erfc = cast1 Unmanaged.tensor_erfc
+
+tensor_erfc_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_erfc_ = cast1 Unmanaged.tensor_erfc_
+
+tensor_exp
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_exp = cast1 Unmanaged.tensor_exp
+
+tensor_exp_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_exp_ = cast1 Unmanaged.tensor_exp_
+
+tensor_exp2
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_exp2 = cast1 Unmanaged.tensor_exp2
+
+tensor_exp2_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_exp2_ = cast1 Unmanaged.tensor_exp2_
+
+tensor_expm1
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_expm1 = cast1 Unmanaged.tensor_expm1
+
+tensor_expm1_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_expm1_ = cast1 Unmanaged.tensor_expm1_
+
+tensor_expand_lb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_expand_lb = cast3 Unmanaged.tensor_expand_lb
+
+tensor_expand_as_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_expand_as_t = cast2 Unmanaged.tensor_expand_as_t
+
+tensor_flatten_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_flatten_ll = cast3 Unmanaged.tensor_flatten_ll
+
+tensor_flatten_lln
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+tensor_flatten_lln = cast4 Unmanaged.tensor_flatten_lln
+
+tensor_flatten_nnn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+tensor_flatten_nnn = cast4 Unmanaged.tensor_flatten_nnn
+
+tensor_flatten_Nn
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+tensor_flatten_Nn = cast3 Unmanaged.tensor_flatten_Nn
+
+tensor_unflatten_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_unflatten_ll = cast3 Unmanaged.tensor_unflatten_ll
+
+tensor_unflatten_nlN
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr IntArray
+  -> ForeignPtr DimnameList
+  -> IO (ForeignPtr Tensor)
+tensor_unflatten_nlN = cast4 Unmanaged.tensor_unflatten_nlN
+
+tensor_fill__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_fill__s = cast2 Unmanaged.tensor_fill__s
+
+tensor_fill__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_fill__t = cast2 Unmanaged.tensor_fill__t
+
+tensor_floor
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_floor = cast1 Unmanaged.tensor_floor
+
+tensor_floor_
+  :: ForeignPtr Tensor
+  -> 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)
+tensor_frac = cast1 Unmanaged.tensor_frac
+
+tensor_frac_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_frac_ = cast1 Unmanaged.tensor_frac_
+
+tensor_gcd_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_gcd_t = cast2 Unmanaged.tensor_gcd_t
+
+tensor_gcd__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_gcd__t = cast2 Unmanaged.tensor_gcd__t
+
+tensor_lcm_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lcm_t = cast2 Unmanaged.tensor_lcm_t
+
+tensor_lcm__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lcm__t = cast2 Unmanaged.tensor_lcm__t
+
+tensor_index_l
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> IO (ForeignPtr Tensor)
+tensor_index_l = cast2 Unmanaged.tensor_index_l
+
+tensor_index_copy__ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_copy__ltt = cast4 Unmanaged.tensor_index_copy__ltt
+
+tensor_index_copy_ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_copy_ltt = cast4 Unmanaged.tensor_index_copy_ltt
+
+tensor_index_copy__ntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_copy__ntt = cast4 Unmanaged.tensor_index_copy__ntt
+
+tensor_index_copy_ntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_copy_ntt = cast4 Unmanaged.tensor_index_copy_ntt
+
+tensor_index_put__ltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_index_put__ltb = cast4 Unmanaged.tensor_index_put__ltb
+
+tensor_index_put_ltb
+  :: ForeignPtr Tensor
+  -> ForeignPtr (C10List (C10Optional Tensor))
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_index_put_ltb = cast4 Unmanaged.tensor_index_put_ltb
+
+tensor_isclose_tddb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_isclose_tddb = cast5 Unmanaged.tensor_isclose_tddb
+
+tensor_isnan
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_isnan = cast1 Unmanaged.tensor_isnan
+
+tensor_is_distributed
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_distributed = cast1 Unmanaged.tensor_is_distributed
+
+tensor_is_floating_point
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_floating_point = cast1 Unmanaged.tensor_is_floating_point
+
+tensor_is_complex
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_complex = cast1 Unmanaged.tensor_is_complex
+
+tensor_is_conj
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_conj = cast1 Unmanaged.tensor_is_conj
+
+tensor__is_zerotensor
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor__is_zerotensor = cast1 Unmanaged.tensor__is_zerotensor
+
+tensor_is_neg
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_neg = cast1 Unmanaged.tensor_is_neg
+
+tensor_isreal
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_isreal = cast1 Unmanaged.tensor_isreal
+
+tensor_is_nonzero
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_nonzero = cast1 Unmanaged.tensor_is_nonzero
+
+tensor_is_same_size_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_same_size_t = cast2 Unmanaged.tensor_is_same_size_t
+
+tensor_is_signed
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_signed = cast1 Unmanaged.tensor_is_signed
+
+tensor_is_inference
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_inference = cast1 Unmanaged.tensor_is_inference
+
+tensor_kron_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_kron_t = cast2 Unmanaged.tensor_kron_t
+
+tensor_kthvalue_llb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_kthvalue_llb = cast4 Unmanaged.tensor_kthvalue_llb
+
+tensor_kthvalue_lnb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_kthvalue_lnb = cast4 Unmanaged.tensor_kthvalue_lnb
+
+tensor_nan_to_num_ddd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+tensor_nan_to_num_ddd = cast4 Unmanaged.tensor_nan_to_num_ddd
+
+tensor_nan_to_num__ddd
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+tensor_nan_to_num__ddd = cast4 Unmanaged.tensor_nan_to_num__ddd
+
+tensor_ldexp_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ldexp_t = cast2 Unmanaged.tensor_ldexp_t
+
+tensor_ldexp__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ldexp__t = cast2 Unmanaged.tensor_ldexp__t
+
+tensor_log
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_log = cast1 Unmanaged.tensor_log
+
+tensor_log_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_log_ = cast1 Unmanaged.tensor_log_
+
+tensor_log10
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_log10 = cast1 Unmanaged.tensor_log10
+
+tensor_log10_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_log10_ = cast1 Unmanaged.tensor_log10_
+
+tensor_log1p
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_log1p = cast1 Unmanaged.tensor_log1p
+
+tensor_log1p_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_log1p_ = cast1 Unmanaged.tensor_log1p_
+
+tensor_log2
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_log2 = cast1 Unmanaged.tensor_log2
+
+tensor_log2_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_log2_ = cast1 Unmanaged.tensor_log2_
+
+tensor_logaddexp_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logaddexp_t = cast2 Unmanaged.tensor_logaddexp_t
+
+tensor_logaddexp2_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logaddexp2_t = cast2 Unmanaged.tensor_logaddexp2_t
+
+tensor_xlogy_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_xlogy_t = cast2 Unmanaged.tensor_xlogy_t
+
+tensor_xlogy_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_xlogy_s = cast2 Unmanaged.tensor_xlogy_s
+
+tensor_xlogy__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_xlogy__t = cast2 Unmanaged.tensor_xlogy__t
+
+tensor_xlogy__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_xlogy__s = cast2 Unmanaged.tensor_xlogy__s
+
+tensor_log_softmax_ls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_log_softmax_ls = cast3 Unmanaged.tensor_log_softmax_ls
+
+tensor_log_softmax_ns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_log_softmax_ns = cast3 Unmanaged.tensor_log_softmax_ns
+
+tensor_logcumsumexp_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_logcumsumexp_l = cast2 Unmanaged.tensor_logcumsumexp_l
+
+tensor_logcumsumexp_n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+tensor_logcumsumexp_n = cast2 Unmanaged.tensor_logcumsumexp_n
+
+tensor_logsumexp_lb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_logsumexp_lb = cast3 Unmanaged.tensor_logsumexp_lb
+
+tensor_logsumexp_Nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_logsumexp_Nb = cast3 Unmanaged.tensor_logsumexp_Nb
+
+tensor_matmul_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_matmul_t = cast2 Unmanaged.tensor_matmul_t
+
+tensor_matrix_power_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_matrix_power_l = cast2 Unmanaged.tensor_matrix_power_l
+
+tensor_matrix_exp
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_matrix_exp = cast1 Unmanaged.tensor_matrix_exp
+
+tensor_aminmax_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_aminmax_lb = cast3 Unmanaged.tensor_aminmax_lb
+
+tensor_max_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_max_lb = cast3 Unmanaged.tensor_max_lb
+
+tensor_max_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_max_nb = cast3 Unmanaged.tensor_max_nb
+
+tensor_amax_lb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_amax_lb = cast3 Unmanaged.tensor_amax_lb
+
+tensor_mean_s
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_mean_s = cast2 Unmanaged.tensor_mean_s
+
+tensor_mean_lbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_mean_lbs = cast4 Unmanaged.tensor_mean_lbs
+
+tensor_mean_Nbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_mean_Nbs = cast4 Unmanaged.tensor_mean_Nbs
+
+tensor_nanmean_lbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_nanmean_lbs = cast4 Unmanaged.tensor_nanmean_lbs
+
+tensor_median
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_median = cast1 Unmanaged.tensor_median
+
+tensor_median_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_median_lb = cast3 Unmanaged.tensor_median_lb
+
+tensor_median_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_median_nb = cast3 Unmanaged.tensor_median_nb
+
+tensor_nanmedian
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_nanmedian = cast1 Unmanaged.tensor_nanmedian
+
+tensor_nanmedian_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_nanmedian_lb = cast3 Unmanaged.tensor_nanmedian_lb
+
+tensor_nanmedian_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_nanmedian_nb = cast3 Unmanaged.tensor_nanmedian_nb
+
+tensor_min_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_min_lb = cast3 Unmanaged.tensor_min_lb
+
+tensor_min_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_min_nb = cast3 Unmanaged.tensor_min_nb
+
+tensor_amin_lb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_amin_lb = cast3 Unmanaged.tensor_amin_lb
+
+tensor_mm_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_mm_t = cast2 Unmanaged.tensor_mm_t
+
+tensor_mode_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_mode_lb = cast3 Unmanaged.tensor_mode_lb
+
+tensor_mode_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_mode_nb = cast3 Unmanaged.tensor_mode_nb
+
+tensor_mul_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_mul_t = cast2 Unmanaged.tensor_mul_t
+
+tensor_mul__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_mul__t = cast2 Unmanaged.tensor_mul__t
+
+tensor_mul_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_mul_s = cast2 Unmanaged.tensor_mul_s
+
+tensor_mul__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_mul__s = cast2 Unmanaged.tensor_mul__s
+
+tensor_multiply_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_multiply_t = cast2 Unmanaged.tensor_multiply_t
+
+tensor_multiply__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_multiply__t = cast2 Unmanaged.tensor_multiply__t
+
+tensor_multiply_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_multiply_s = cast2 Unmanaged.tensor_multiply_s
+
+tensor_multiply__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_multiply__s = cast2 Unmanaged.tensor_multiply__s
+
+tensor_mv_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_mv_t = cast2 Unmanaged.tensor_mv_t
+
+tensor_mvlgamma_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_mvlgamma_l = cast2 Unmanaged.tensor_mvlgamma_l
+
+tensor_mvlgamma__l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_mvlgamma__l = cast2 Unmanaged.tensor_mvlgamma__l
+
+tensor_narrow_copy_lll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_narrow_copy_lll = cast4 Unmanaged.tensor_narrow_copy_lll
+
+tensor_narrow_lll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> 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
+  -> IO (ForeignPtr Tensor)
+tensor_permute_l = cast2 Unmanaged.tensor_permute_l
+
+tensor_numpy_T
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_numpy_T = cast1 Unmanaged.tensor_numpy_T
+
+tensor_matrix_H
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_matrix_H = cast1 Unmanaged.tensor_matrix_H
+
+tensor_mT
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_mT = cast1 Unmanaged.tensor_mT
+
+tensor_mH
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_mH = cast1 Unmanaged.tensor_mH
+
+tensor_adjoint
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_adjoint = cast1 Unmanaged.tensor_adjoint
+
+tensor_is_pinned_D
+  :: ForeignPtr Tensor
+  -> DeviceType
+  -> IO (CBool)
+tensor_is_pinned_D = cast2 Unmanaged.tensor_is_pinned_D
+
+tensor_pin_memory_D
+  :: ForeignPtr Tensor
+  -> DeviceType
+  -> IO (ForeignPtr Tensor)
+tensor_pin_memory_D = cast2 Unmanaged.tensor_pin_memory_D
+
+tensor_pinverse_d
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+tensor_pinverse_d = cast2 Unmanaged.tensor_pinverse_d
+
+tensor_rad2deg
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_rad2deg = cast1 Unmanaged.tensor_rad2deg
+
+tensor_rad2deg_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_rad2deg_ = cast1 Unmanaged.tensor_rad2deg_
+
+tensor_deg2rad
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_deg2rad = cast1 Unmanaged.tensor_deg2rad
+
+tensor_deg2rad_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_deg2rad_ = cast1 Unmanaged.tensor_deg2rad_
+
+tensor_ravel
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ravel = cast1 Unmanaged.tensor_ravel
+
+tensor_reciprocal
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_reciprocal = cast1 Unmanaged.tensor_reciprocal
+
+tensor_reciprocal_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_reciprocal_ = cast1 Unmanaged.tensor_reciprocal_
+
+tensor_neg
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_neg = cast1 Unmanaged.tensor_neg
+
+tensor_neg_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_neg_ = cast1 Unmanaged.tensor_neg_
+
+tensor_negative
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_negative = cast1 Unmanaged.tensor_negative
+
+tensor_negative_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_negative_ = cast1 Unmanaged.tensor_negative_
+
+tensor_repeat_l
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_repeat_l = cast2 Unmanaged.tensor_repeat_l
+
+tensor_repeat_interleave_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_repeat_interleave_tll = cast4 Unmanaged.tensor_repeat_interleave_tll
+
+tensor_repeat_interleave_lll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_repeat_interleave_lll = cast4 Unmanaged.tensor_repeat_interleave_lll
+
+tensor_reshape_l
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_reshape_l = cast2 Unmanaged.tensor_reshape_l
+
+tensor__reshape_alias_ll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor__reshape_alias_ll = cast3 Unmanaged.tensor__reshape_alias_ll
+
+tensor_reshape_as_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_reshape_as_t = cast2 Unmanaged.tensor_reshape_as_t
+
+tensor_round
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_round = cast1 Unmanaged.tensor_round
+
+tensor_round_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_round_ = cast1 Unmanaged.tensor_round_
+
+tensor_round_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_round_l = cast2 Unmanaged.tensor_round_l
+
+tensor_round__l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_round__l = cast2 Unmanaged.tensor_round__l
+
+tensor_relu
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_relu = cast1 Unmanaged.tensor_relu
+
+tensor_relu_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_relu_ = cast1 Unmanaged.tensor_relu_
+
+tensor_prelu_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_prelu_t = cast2 Unmanaged.tensor_prelu_t
+
+tensor_hardshrink_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_hardshrink_s = cast2 Unmanaged.tensor_hardshrink_s
+
+tensor_hardshrink_backward_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_hardshrink_backward_ts = cast3 Unmanaged.tensor_hardshrink_backward_ts
+
+tensor_rsqrt
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_rsqrt = cast1 Unmanaged.tensor_rsqrt
+
+tensor_rsqrt_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_rsqrt_ = cast1 Unmanaged.tensor_rsqrt_
+
+tensor_select_nl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_select_nl = cast3 Unmanaged.tensor_select_nl
+
+tensor_select_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_select_ll = cast3 Unmanaged.tensor_select_ll
+
+tensor_sigmoid
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sigmoid = cast1 Unmanaged.tensor_sigmoid
+
+tensor_sigmoid_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sigmoid_ = cast1 Unmanaged.tensor_sigmoid_
+
+tensor_logit_d
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+tensor_logit_d = cast2 Unmanaged.tensor_logit_d
+
+tensor_logit__d
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> IO (ForeignPtr Tensor)
+tensor_logit__d = cast2 Unmanaged.tensor_logit__d
+
+tensor_sin
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sin = cast1 Unmanaged.tensor_sin
+
+tensor_sin_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sin_ = cast1 Unmanaged.tensor_sin_
+
+tensor_sinc
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sinc = cast1 Unmanaged.tensor_sinc
+
+tensor_sinc_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sinc_ = cast1 Unmanaged.tensor_sinc_
+
+tensor_sinh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sinh = cast1 Unmanaged.tensor_sinh
+
diff --git a/src/Torch/Internal/Managed/Type/Tensor/Tensor2.hs b/src/Torch/Internal/Managed/Type/Tensor/Tensor2.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Tensor/Tensor2.hs
@@ -0,0 +1,1426 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Tensor.Tensor2 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Tensor.Tensor2 as Unmanaged
+
+
+
+
+
+tensor_sinh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sinh_ = cast1 Unmanaged.tensor_sinh_
+
+tensor_detach
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_detach = cast1 Unmanaged.tensor_detach
+
+tensor_detach_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_detach_ = cast1 Unmanaged.tensor_detach_
+
+tensor_size_n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (Int64)
+tensor_size_n = cast2 Unmanaged.tensor_size_n
+
+tensor_slice_llll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_slice_llll = cast5 Unmanaged.tensor_slice_llll
+
+tensor_slice_scatter_tllll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_slice_scatter_tllll = cast6 Unmanaged.tensor_slice_scatter_tllll
+
+tensor_select_scatter_tll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_select_scatter_tll = cast4 Unmanaged.tensor_select_scatter_tll
+
+tensor_diagonal_scatter_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_diagonal_scatter_tlll = cast5 Unmanaged.tensor_diagonal_scatter_tlll
+
+tensor_as_strided_scatter_tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_as_strided_scatter_tlll = cast5 Unmanaged.tensor_as_strided_scatter_tlll
+
+tensor_smm_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_smm_t = cast2 Unmanaged.tensor_smm_t
+
+tensor_softmax_ls
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_softmax_ls = cast3 Unmanaged.tensor_softmax_ls
+
+tensor_softmax_ns
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_softmax_ns = cast3 Unmanaged.tensor_softmax_ns
+
+tensor_unsafe_split_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_unsafe_split_ll = cast3 Unmanaged.tensor_unsafe_split_ll
+
+tensor_split_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_split_ll = cast3 Unmanaged.tensor_split_ll
+
+-- tensor_split_ll
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr IntArray
+--   -> Int64
+--   -> IO (ForeignPtr TensorList)
+-- tensor_split_ll = cast3 Unmanaged.tensor_split_ll
+
+tensor_unsafe_split_with_sizes_ll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_unsafe_split_with_sizes_ll = cast3 Unmanaged.tensor_unsafe_split_with_sizes_ll
+
+tensor_split_with_sizes_ll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_split_with_sizes_ll = cast3 Unmanaged.tensor_split_with_sizes_ll
+
+tensor_squeeze
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_squeeze = cast1 Unmanaged.tensor_squeeze
+
+tensor_squeeze_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_squeeze_l = cast2 Unmanaged.tensor_squeeze_l
+
+tensor_squeeze_n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+tensor_squeeze_n = cast2 Unmanaged.tensor_squeeze_n
+
+-- tensor_squeeze_l
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr IntArray
+--   -> IO (ForeignPtr Tensor)
+-- tensor_squeeze_l = cast2 Unmanaged.tensor_squeeze_l
+
+tensor_squeeze_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_squeeze_ = cast1 Unmanaged.tensor_squeeze_
+
+tensor_squeeze__l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_squeeze__l = cast2 Unmanaged.tensor_squeeze__l
+
+-- tensor_squeeze__l
+--   :: ForeignPtr Tensor
+--   -> ForeignPtr IntArray
+--   -> IO (ForeignPtr Tensor)
+-- tensor_squeeze__l = cast2 Unmanaged.tensor_squeeze__l
+
+tensor_squeeze__n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+tensor_squeeze__n = cast2 Unmanaged.tensor_squeeze__n
+
+tensor_sspaddmm_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_sspaddmm_ttss = cast5 Unmanaged.tensor_sspaddmm_ttss
+
+tensor_stft_llltbbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_stft_llltbbb = cast8 Unmanaged.tensor_stft_llltbbb
+
+tensor_stft_llltbsbbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr StdString
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_stft_llltbsbbb = cast10 Unmanaged.tensor_stft_llltbsbbb
+
+tensor_istft_llltbbblb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_istft_llltbbblb = cast10 Unmanaged.tensor_istft_llltbbblb
+
+tensor_stride_n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (Int64)
+tensor_stride_n = cast2 Unmanaged.tensor_stride_n
+
+tensor_sum_s
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_sum_s = cast2 Unmanaged.tensor_sum_s
+
+tensor_sum_lbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_sum_lbs = cast4 Unmanaged.tensor_sum_lbs
+
+tensor_sum_Nbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_sum_Nbs = cast4 Unmanaged.tensor_sum_Nbs
+
+tensor_nansum_lbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_nansum_lbs = cast4 Unmanaged.tensor_nansum_lbs
+
+tensor_sum_to_size_l
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_sum_to_size_l = cast2 Unmanaged.tensor_sum_to_size_l
+
+tensor_sqrt
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sqrt = cast1 Unmanaged.tensor_sqrt
+
+tensor_sqrt_
+  :: ForeignPtr Tensor
+  -> 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
+  -> IO (ForeignPtr Tensor)
+tensor_std_b = cast2 Unmanaged.tensor_std_b
+
+tensor_std_lbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_std_lbb = cast4 Unmanaged.tensor_std_lbb
+
+tensor_std_llb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_std_llb = cast4 Unmanaged.tensor_std_llb
+
+tensor_std_Nbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_std_Nbb = cast4 Unmanaged.tensor_std_Nbb
+
+tensor_std_Nlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_std_Nlb = cast4 Unmanaged.tensor_std_Nlb
+
+tensor_prod_s
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_prod_s = cast2 Unmanaged.tensor_prod_s
+
+tensor_prod_lbs
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_prod_lbs = cast4 Unmanaged.tensor_prod_lbs
+
+tensor_prod_nbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_prod_nbs = cast4 Unmanaged.tensor_prod_nbs
+
+tensor_t
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_t = cast1 Unmanaged.tensor_t
+
+tensor_t_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_t_ = cast1 Unmanaged.tensor_t_
+
+tensor_tan
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_tan = cast1 Unmanaged.tensor_tan
+
+tensor_tan_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_tan_ = cast1 Unmanaged.tensor_tan_
+
+tensor_tanh
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_tanh = cast1 Unmanaged.tensor_tanh
+
+tensor_tanh_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_tanh_ = cast1 Unmanaged.tensor_tanh_
+
+tensor_tile_l
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_tile_l = cast2 Unmanaged.tensor_tile_l
+
+tensor_transpose_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_transpose_ll = cast3 Unmanaged.tensor_transpose_ll
+
+tensor_transpose_nn
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr Tensor)
+tensor_transpose_nn = cast3 Unmanaged.tensor_transpose_nn
+
+tensor_transpose__ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_transpose__ll = cast3 Unmanaged.tensor_transpose__ll
+
+tensor_flip_l
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_flip_l = cast2 Unmanaged.tensor_flip_l
+
+tensor_fliplr
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_fliplr = cast1 Unmanaged.tensor_fliplr
+
+tensor_flipud
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_flipud = cast1 Unmanaged.tensor_flipud
+
+tensor_roll_ll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_roll_ll = cast3 Unmanaged.tensor_roll_ll
+
+tensor_rot90_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_rot90_ll = cast3 Unmanaged.tensor_rot90_ll
+
+tensor__nested_tensor_size
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__nested_tensor_size = cast1 Unmanaged.tensor__nested_tensor_size
+
+tensor__nested_tensor_strides
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__nested_tensor_strides = cast1 Unmanaged.tensor__nested_tensor_strides
+
+-- tensor__nested_tensor_offsets
+--   :: ForeignPtr Tensor
+--   -> IO (ForeignPtr IntArray)
+-- tensor__nested_tensor_offsets = cast1 Unmanaged.tensor__nested_tensor_offsets
+
+tensor_trunc
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_trunc = cast1 Unmanaged.tensor_trunc
+
+tensor_trunc_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_trunc_ = cast1 Unmanaged.tensor_trunc_
+
+tensor_fix
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_fix = cast1 Unmanaged.tensor_fix
+
+tensor_fix_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_fix_ = cast1 Unmanaged.tensor_fix_
+
+tensor_type_as_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_type_as_t = cast2 Unmanaged.tensor_type_as_t
+
+tensor_unsqueeze_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_unsqueeze_l = cast2 Unmanaged.tensor_unsqueeze_l
+
+tensor_unsqueeze__l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_unsqueeze__l = cast2 Unmanaged.tensor_unsqueeze__l
+
+tensor_var_b
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_var_b = cast2 Unmanaged.tensor_var_b
+
+tensor_var_lbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_var_lbb = cast4 Unmanaged.tensor_var_lbb
+
+tensor_var_llb
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_var_llb = cast4 Unmanaged.tensor_var_llb
+
+tensor_var_Nbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_var_Nbb = cast4 Unmanaged.tensor_var_Nbb
+
+tensor_var_Nlb
+  :: ForeignPtr Tensor
+  -> ForeignPtr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_var_Nlb = cast4 Unmanaged.tensor_var_Nlb
+
+tensor_view_as_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_view_as_t = cast2 Unmanaged.tensor_view_as_t
+
+tensor_where_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_where_tt = cast3 Unmanaged.tensor_where_tt
+
+tensor_where_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_where_ts = cast3 Unmanaged.tensor_where_ts
+
+tensor_norm_ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_norm_ss = cast3 Unmanaged.tensor_norm_ss
+
+tensor_norm_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_norm_s = cast2 Unmanaged.tensor_norm_s
+
+tensor_norm_slbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_norm_slbs = cast5 Unmanaged.tensor_norm_slbs
+
+tensor_norm_slb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr IntArray
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_norm_slb = cast4 Unmanaged.tensor_norm_slb
+
+tensor_norm_sNbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_norm_sNbs = cast5 Unmanaged.tensor_norm_sNbs
+
+tensor_norm_sNb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr DimnameList
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_norm_sNb = cast4 Unmanaged.tensor_norm_sNb
+
+tensor_frexp
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_frexp = cast1 Unmanaged.tensor_frexp
+
+tensor_clone_M
+  :: ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_clone_M = cast2 Unmanaged.tensor_clone_M
+
+tensor_positive
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_positive = cast1 Unmanaged.tensor_positive
+
+tensor_resize_as__tM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_resize_as__tM = cast3 Unmanaged.tensor_resize_as__tM
+
+tensor_resize_as_sparse__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_resize_as_sparse__t = cast2 Unmanaged.tensor_resize_as_sparse__t
+
+tensor_zero_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_zero_ = cast1 Unmanaged.tensor_zero_
+
+tensor_sub_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_sub_ts = cast3 Unmanaged.tensor_sub_ts
+
+tensor_sub__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_sub__ts = cast3 Unmanaged.tensor_sub__ts
+
+tensor_sub_ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_sub_ss = cast3 Unmanaged.tensor_sub_ss
+
+tensor_sub__ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_sub__ss = cast3 Unmanaged.tensor_sub__ss
+
+tensor_subtract_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_subtract_ts = cast3 Unmanaged.tensor_subtract_ts
+
+tensor_subtract__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_subtract__ts = cast3 Unmanaged.tensor_subtract__ts
+
+tensor_subtract_ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_subtract_ss = cast3 Unmanaged.tensor_subtract_ss
+
+tensor_subtract__ss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_subtract__ss = cast3 Unmanaged.tensor_subtract__ss
+
+tensor_heaviside_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_heaviside_t = cast2 Unmanaged.tensor_heaviside_t
+
+tensor_heaviside__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_heaviside__t = cast2 Unmanaged.tensor_heaviside__t
+
+tensor_addmm_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addmm_ttss = cast5 Unmanaged.tensor_addmm_ttss
+
+tensor_addmm__ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addmm__ttss = cast5 Unmanaged.tensor_addmm__ttss
+
+tensor__addmm_activation_ttssb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor__addmm_activation_ttssb = cast6 Unmanaged.tensor__addmm_activation_ttssb
+
+tensor_sparse_resize__lll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_sparse_resize__lll = cast4 Unmanaged.tensor_sparse_resize__lll
+
+tensor_sparse_resize_and_clear__lll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_sparse_resize_and_clear__lll = cast4 Unmanaged.tensor_sparse_resize_and_clear__lll
+
+tensor_sparse_mask_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sparse_mask_t = cast2 Unmanaged.tensor_sparse_mask_t
+
+tensor_to_dense_s
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_to_dense_s = cast2 Unmanaged.tensor_to_dense_s
+
+tensor__to_dense_s
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor__to_dense_s = cast2 Unmanaged.tensor__to_dense_s
+
+tensor_sparse_dim
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_sparse_dim = cast1 Unmanaged.tensor_sparse_dim
+
+tensor__dimI
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor__dimI = cast1 Unmanaged.tensor__dimI
+
+tensor_dense_dim
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_dense_dim = cast1 Unmanaged.tensor_dense_dim
+
+tensor__dimV
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor__dimV = cast1 Unmanaged.tensor__dimV
+
+tensor__nnz
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor__nnz = cast1 Unmanaged.tensor__nnz
+
+tensor_coalesce
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_coalesce = cast1 Unmanaged.tensor_coalesce
+
+tensor_is_coalesced
+  :: ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_coalesced = cast1 Unmanaged.tensor_is_coalesced
+
+tensor__indices
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__indices = cast1 Unmanaged.tensor__indices
+
+tensor__values
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor__values = cast1 Unmanaged.tensor__values
+
+tensor__coalesced__b
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor__coalesced__b = cast2 Unmanaged.tensor__coalesced__b
+
+tensor_indices
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_indices = cast1 Unmanaged.tensor_indices
+
+tensor_values
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_values = cast1 Unmanaged.tensor_values
+
+tensor_crow_indices
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_crow_indices = cast1 Unmanaged.tensor_crow_indices
+
+tensor_col_indices
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_col_indices = cast1 Unmanaged.tensor_col_indices
+
+tensor_ccol_indices
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ccol_indices = cast1 Unmanaged.tensor_ccol_indices
+
+tensor_row_indices
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_row_indices = cast1 Unmanaged.tensor_row_indices
+
+tensor_unbind_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr TensorList)
+tensor_unbind_l = cast2 Unmanaged.tensor_unbind_l
+
+tensor_unbind_n
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> IO (ForeignPtr TensorList)
+tensor_unbind_n = cast2 Unmanaged.tensor_unbind_n
+
+tensor_to_sparse_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_to_sparse_l = cast2 Unmanaged.tensor_to_sparse_l
+
+tensor_to_sparse_Lll
+  :: ForeignPtr Tensor
+  -> Layout
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_to_sparse_Lll = cast4 Unmanaged.tensor_to_sparse_Lll
+
+tensor_to_sparse_csr_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_to_sparse_csr_l = cast2 Unmanaged.tensor_to_sparse_csr_l
+
+tensor_to_sparse_csc_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_to_sparse_csc_l = cast2 Unmanaged.tensor_to_sparse_csc_l
+
+tensor_to_sparse_bsr_ll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_to_sparse_bsr_ll = cast3 Unmanaged.tensor_to_sparse_bsr_ll
+
+tensor_to_sparse_bsc_ll
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_to_sparse_bsc_ll = cast3 Unmanaged.tensor_to_sparse_bsc_ll
+
+tensor_to_mkldnn_s
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_to_mkldnn_s = cast2 Unmanaged.tensor_to_mkldnn_s
+
+tensor_dequantize
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_dequantize = cast1 Unmanaged.tensor_dequantize
+
+tensor_q_scale
+  :: ForeignPtr Tensor
+  -> IO (CDouble)
+tensor_q_scale = cast1 Unmanaged.tensor_q_scale
+
+tensor_q_zero_point
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_q_zero_point = cast1 Unmanaged.tensor_q_zero_point
+
+tensor_q_per_channel_scales
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_q_per_channel_scales = cast1 Unmanaged.tensor_q_per_channel_scales
+
+tensor_q_per_channel_zero_points
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_q_per_channel_zero_points = cast1 Unmanaged.tensor_q_per_channel_zero_points
+
+tensor_q_per_channel_axis
+  :: ForeignPtr Tensor
+  -> IO (Int64)
+tensor_q_per_channel_axis = cast1 Unmanaged.tensor_q_per_channel_axis
+
+tensor_int_repr
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_int_repr = cast1 Unmanaged.tensor_int_repr
+
+tensor_qscheme
+  :: ForeignPtr Tensor
+  -> IO (QScheme)
+tensor_qscheme = cast1 Unmanaged.tensor_qscheme
+
+tensor__autocast_to_reduced_precision_bbss
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> ScalarType
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor__autocast_to_reduced_precision_bbss = cast5 Unmanaged.tensor__autocast_to_reduced_precision_bbss
+
+tensor__autocast_to_full_precision_bb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor__autocast_to_full_precision_bb = cast3 Unmanaged.tensor__autocast_to_full_precision_bb
+
+tensor_to_obbM
+  :: ForeignPtr Tensor
+  -> ForeignPtr TensorOptions
+  -> CBool
+  -> CBool
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_to_obbM = cast5 Unmanaged.tensor_to_obbM
+
+tensor_to_DsbbM
+  :: ForeignPtr Tensor
+  -> DeviceType
+  -> ScalarType
+  -> CBool
+  -> CBool
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_to_DsbbM = cast6 Unmanaged.tensor_to_DsbbM
+
+tensor_to_sbbM
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> CBool
+  -> CBool
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_to_sbbM = cast5 Unmanaged.tensor_to_sbbM
+
+tensor_to_tbbM
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> MemoryFormat
+  -> IO (ForeignPtr Tensor)
+tensor_to_tbbM = cast5 Unmanaged.tensor_to_tbbM
+
+tensor_item
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Scalar)
+tensor_item = cast1 Unmanaged.tensor_item
+
+tensor_set__S
+  :: ForeignPtr Tensor
+  -> ForeignPtr Storage
+  -> IO (ForeignPtr Tensor)
+tensor_set__S = cast2 Unmanaged.tensor_set__S
+
+tensor_set__Slll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Storage
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_set__Slll = cast5 Unmanaged.tensor_set__Slll
+
+tensor_set__tlll
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr IntArray
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_set__tlll = cast5 Unmanaged.tensor_set__tlll
+
+tensor_set__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_set__t = cast2 Unmanaged.tensor_set__t
+
+tensor_set_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_set_ = cast1 Unmanaged.tensor_set_
+
+tensor_is_set_to_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+tensor_is_set_to_t = cast2 Unmanaged.tensor_is_set_to_t
+
+tensor_masked_fill__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_masked_fill__ts = cast3 Unmanaged.tensor_masked_fill__ts
+
+tensor_masked_fill_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_masked_fill_ts = cast3 Unmanaged.tensor_masked_fill_ts
+
+tensor_masked_fill__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_masked_fill__tt = cast3 Unmanaged.tensor_masked_fill__tt
+
+tensor_masked_fill_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_masked_fill_tt = cast3 Unmanaged.tensor_masked_fill_tt
+
+tensor_masked_scatter__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_masked_scatter__tt = cast3 Unmanaged.tensor_masked_scatter__tt
+
+tensor_masked_scatter_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_masked_scatter_tt = cast3 Unmanaged.tensor_masked_scatter_tt
+
+tensor_view_l
+  :: ForeignPtr Tensor
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_view_l = cast2 Unmanaged.tensor_view_l
+
+tensor_view_s
+  :: ForeignPtr Tensor
+  -> ScalarType
+  -> IO (ForeignPtr Tensor)
+tensor_view_s = cast2 Unmanaged.tensor_view_s
+
+tensor_put__ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_put__ttb = cast4 Unmanaged.tensor_put__ttb
+
+tensor_put_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_put_ttb = cast4 Unmanaged.tensor_put_ttb
+
+tensor_index_add__ltts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_index_add__ltts = cast5 Unmanaged.tensor_index_add__ltts
+
+tensor_index_add_ltts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_index_add_ltts = cast5 Unmanaged.tensor_index_add_ltts
+
+tensor_index_add_ntts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_index_add_ntts = cast5 Unmanaged.tensor_index_add_ntts
+
+tensor_index_reduce__lttsb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_index_reduce__lttsb = cast6 Unmanaged.tensor_index_reduce__lttsb
+
+tensor_index_reduce_lttsb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_index_reduce_lttsb = cast6 Unmanaged.tensor_index_reduce_lttsb
+
+tensor_index_fill__lts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_index_fill__lts = cast4 Unmanaged.tensor_index_fill__lts
+
+tensor_index_fill_lts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_index_fill_lts = cast4 Unmanaged.tensor_index_fill_lts
+
+tensor_index_fill__ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_fill__ltt = cast4 Unmanaged.tensor_index_fill__ltt
+
+tensor_index_fill_ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_fill_ltt = cast4 Unmanaged.tensor_index_fill_ltt
+
+tensor_index_fill__nts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_index_fill__nts = cast4 Unmanaged.tensor_index_fill__nts
+
+tensor_index_fill__ntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_fill__ntt = cast4 Unmanaged.tensor_index_fill__ntt
+
+tensor_index_fill_nts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_index_fill_nts = cast4 Unmanaged.tensor_index_fill_nts
+
+tensor_index_fill_ntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_fill_ntt = cast4 Unmanaged.tensor_index_fill_ntt
+
+tensor_scatter_ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_ltt = cast4 Unmanaged.tensor_scatter_ltt
+
+tensor_scatter__ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_scatter__ltt = cast4 Unmanaged.tensor_scatter__ltt
+
+tensor_scatter_lts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_lts = cast4 Unmanaged.tensor_scatter_lts
+
+tensor_scatter__lts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_scatter__lts = cast4 Unmanaged.tensor_scatter__lts
+
+tensor_scatter_ltts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_ltts = cast5 Unmanaged.tensor_scatter_ltts
+
+tensor_scatter__ltts
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_scatter__ltts = cast5 Unmanaged.tensor_scatter__ltts
+
+tensor_scatter_ltss
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_ltss = cast5 Unmanaged.tensor_scatter_ltss
+
+tensor_scatter__ltss
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_scatter__ltss = cast5 Unmanaged.tensor_scatter__ltss
+
+tensor_scatter_ntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_ntt = cast4 Unmanaged.tensor_scatter_ntt
+
+tensor_scatter_nts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_nts = cast4 Unmanaged.tensor_scatter_nts
+
+tensor_scatter_add_ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_add_ltt = cast4 Unmanaged.tensor_scatter_add_ltt
+
+tensor_scatter_add__ltt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_add__ltt = cast4 Unmanaged.tensor_scatter_add__ltt
+
+tensor_scatter_add_ntt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_add_ntt = cast4 Unmanaged.tensor_scatter_add_ntt
+
+tensor_scatter_reduce_lttsb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_reduce_lttsb = cast6 Unmanaged.tensor_scatter_reduce_lttsb
+
+tensor_scatter_reduce__lttsb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr StdString
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_scatter_reduce__lttsb = cast6 Unmanaged.tensor_scatter_reduce__lttsb
+
+tensor_eq__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_eq__s = cast2 Unmanaged.tensor_eq__s
+
+tensor_eq__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_eq__t = cast2 Unmanaged.tensor_eq__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
+  -> IO (ForeignPtr Tensor)
+tensor___and___s = cast2 Unmanaged.tensor___and___s
+
+tensor___and___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___and___t = cast2 Unmanaged.tensor___and___t
+
+tensor___iand___s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor___iand___s = cast2 Unmanaged.tensor___iand___s
+
+tensor___iand___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> 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
+
diff --git a/src/Torch/Internal/Managed/Type/Tensor/Tensor3.hs b/src/Torch/Internal/Managed/Type/Tensor/Tensor3.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Tensor/Tensor3.hs
@@ -0,0 +1,1344 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Tensor.Tensor3 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Tensor.Tensor3 as Unmanaged
+
+
+
+
+
+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
+  -> IO (ForeignPtr Tensor)
+tensor___or___s = cast2 Unmanaged.tensor___or___s
+
+tensor___or___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___or___t = cast2 Unmanaged.tensor___or___t
+
+tensor___ior___s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor___ior___s = cast2 Unmanaged.tensor___ior___s
+
+tensor___ior___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> 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
+  -> IO (ForeignPtr Tensor)
+tensor___xor___s = cast2 Unmanaged.tensor___xor___s
+
+tensor___xor___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___xor___t = cast2 Unmanaged.tensor___xor___t
+
+tensor___ixor___s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor___ixor___s = cast2 Unmanaged.tensor___ixor___s
+
+tensor___ixor___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___ixor___t = cast2 Unmanaged.tensor___ixor___t
+
+tensor___lshift___s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor___lshift___s = cast2 Unmanaged.tensor___lshift___s
+
+tensor___lshift___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___lshift___t = cast2 Unmanaged.tensor___lshift___t
+
+tensor___ilshift___s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor___ilshift___s = cast2 Unmanaged.tensor___ilshift___s
+
+tensor___ilshift___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___ilshift___t = cast2 Unmanaged.tensor___ilshift___t
+
+tensor_bitwise_left_shift_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_left_shift_t = cast2 Unmanaged.tensor_bitwise_left_shift_t
+
+tensor_bitwise_left_shift__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_left_shift__t = cast2 Unmanaged.tensor_bitwise_left_shift__t
+
+tensor_bitwise_left_shift_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_left_shift_s = cast2 Unmanaged.tensor_bitwise_left_shift_s
+
+tensor_bitwise_left_shift__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_left_shift__s = cast2 Unmanaged.tensor_bitwise_left_shift__s
+
+tensor___rshift___s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor___rshift___s = cast2 Unmanaged.tensor___rshift___s
+
+tensor___rshift___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___rshift___t = cast2 Unmanaged.tensor___rshift___t
+
+tensor___irshift___s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor___irshift___s = cast2 Unmanaged.tensor___irshift___s
+
+tensor___irshift___t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor___irshift___t = cast2 Unmanaged.tensor___irshift___t
+
+tensor_bitwise_right_shift_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_right_shift_t = cast2 Unmanaged.tensor_bitwise_right_shift_t
+
+tensor_bitwise_right_shift__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_right_shift__t = cast2 Unmanaged.tensor_bitwise_right_shift__t
+
+tensor_bitwise_right_shift_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_right_shift_s = cast2 Unmanaged.tensor_bitwise_right_shift_s
+
+tensor_bitwise_right_shift__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_bitwise_right_shift__s = cast2 Unmanaged.tensor_bitwise_right_shift__s
+
+tensor_tril__l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_tril__l = cast2 Unmanaged.tensor_tril__l
+
+tensor_triu__l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_triu__l = cast2 Unmanaged.tensor_triu__l
+
+tensor_digamma_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_digamma_ = cast1 Unmanaged.tensor_digamma_
+
+tensor_lerp__ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_lerp__ts = cast3 Unmanaged.tensor_lerp__ts
+
+tensor_lerp__tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lerp__tt = cast3 Unmanaged.tensor_lerp__tt
+
+tensor_addbmm__ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addbmm__ttss = cast5 Unmanaged.tensor_addbmm__ttss
+
+tensor_addbmm_ttss
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addbmm_ttss = cast5 Unmanaged.tensor_addbmm_ttss
+
+tensor_random__llG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_random__llG = cast4 Unmanaged.tensor_random__llG
+
+tensor_random__lG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_random__lG = cast3 Unmanaged.tensor_random__lG
+
+tensor_random__G
+  :: ForeignPtr Tensor
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_random__G = cast2 Unmanaged.tensor_random__G
+
+tensor_uniform__ddG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_uniform__ddG = cast4 Unmanaged.tensor_uniform__ddG
+
+tensor_cauchy__ddG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_cauchy__ddG = cast4 Unmanaged.tensor_cauchy__ddG
+
+tensor_log_normal__ddG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_log_normal__ddG = cast4 Unmanaged.tensor_log_normal__ddG
+
+tensor_exponential__dG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_exponential__dG = cast3 Unmanaged.tensor_exponential__dG
+
+tensor_geometric__dG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_geometric__dG = cast3 Unmanaged.tensor_geometric__dG
+
+tensor_diag_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_diag_l = cast2 Unmanaged.tensor_diag_l
+
+tensor_cross_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_cross_tl = cast3 Unmanaged.tensor_cross_tl
+
+tensor_triu_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_triu_l = cast2 Unmanaged.tensor_triu_l
+
+tensor_tril_l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_tril_l = cast2 Unmanaged.tensor_tril_l
+
+tensor_trace
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_trace = cast1 Unmanaged.tensor_trace
+
+tensor_ne_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_ne_s = cast2 Unmanaged.tensor_ne_s
+
+tensor_ne_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ne_t = cast2 Unmanaged.tensor_ne_t
+
+tensor_ne__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_ne__s = cast2 Unmanaged.tensor_ne__s
+
+tensor_ne__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ne__t = cast2 Unmanaged.tensor_ne__t
+
+tensor_not_equal_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_not_equal_s = cast2 Unmanaged.tensor_not_equal_s
+
+tensor_not_equal_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_not_equal_t = cast2 Unmanaged.tensor_not_equal_t
+
+tensor_not_equal__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_not_equal__s = cast2 Unmanaged.tensor_not_equal__s
+
+tensor_not_equal__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_not_equal__t = cast2 Unmanaged.tensor_not_equal__t
+
+tensor_eq_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_eq_s = cast2 Unmanaged.tensor_eq_s
+
+tensor_eq_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_eq_t = cast2 Unmanaged.tensor_eq_t
+
+tensor_ge_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_ge_s = cast2 Unmanaged.tensor_ge_s
+
+tensor_ge_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ge_t = cast2 Unmanaged.tensor_ge_t
+
+tensor_ge__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_ge__s = cast2 Unmanaged.tensor_ge__s
+
+tensor_ge__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ge__t = cast2 Unmanaged.tensor_ge__t
+
+tensor_greater_equal_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_greater_equal_s = cast2 Unmanaged.tensor_greater_equal_s
+
+tensor_greater_equal_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_greater_equal_t = cast2 Unmanaged.tensor_greater_equal_t
+
+tensor_greater_equal__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_greater_equal__s = cast2 Unmanaged.tensor_greater_equal__s
+
+tensor_greater_equal__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_greater_equal__t = cast2 Unmanaged.tensor_greater_equal__t
+
+tensor_le_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_le_s = cast2 Unmanaged.tensor_le_s
+
+tensor_le_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_le_t = cast2 Unmanaged.tensor_le_t
+
+tensor_le__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_le__s = cast2 Unmanaged.tensor_le__s
+
+tensor_le__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_le__t = cast2 Unmanaged.tensor_le__t
+
+tensor_less_equal_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_less_equal_s = cast2 Unmanaged.tensor_less_equal_s
+
+tensor_less_equal_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_less_equal_t = cast2 Unmanaged.tensor_less_equal_t
+
+tensor_less_equal__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_less_equal__s = cast2 Unmanaged.tensor_less_equal__s
+
+tensor_less_equal__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_less_equal__t = cast2 Unmanaged.tensor_less_equal__t
+
+tensor_gt_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_gt_s = cast2 Unmanaged.tensor_gt_s
+
+tensor_gt_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_gt_t = cast2 Unmanaged.tensor_gt_t
+
+tensor_gt__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_gt__s = cast2 Unmanaged.tensor_gt__s
+
+tensor_gt__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_gt__t = cast2 Unmanaged.tensor_gt__t
+
+tensor_greater_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_greater_s = cast2 Unmanaged.tensor_greater_s
+
+tensor_greater_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_greater_t = cast2 Unmanaged.tensor_greater_t
+
+tensor_greater__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_greater__s = cast2 Unmanaged.tensor_greater__s
+
+tensor_greater__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_greater__t = cast2 Unmanaged.tensor_greater__t
+
+tensor_lt_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_lt_s = cast2 Unmanaged.tensor_lt_s
+
+tensor_lt_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lt_t = cast2 Unmanaged.tensor_lt_t
+
+tensor_lt__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_lt__s = cast2 Unmanaged.tensor_lt__s
+
+tensor_lt__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lt__t = cast2 Unmanaged.tensor_lt__t
+
+tensor_less_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_less_s = cast2 Unmanaged.tensor_less_s
+
+tensor_less_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_less_t = cast2 Unmanaged.tensor_less_t
+
+tensor_less__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_less__s = cast2 Unmanaged.tensor_less__s
+
+tensor_less__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_less__t = cast2 Unmanaged.tensor_less__t
+
+tensor_take_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_take_t = cast2 Unmanaged.tensor_take_t
+
+tensor_take_along_dim_tl
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_take_along_dim_tl = cast3 Unmanaged.tensor_take_along_dim_tl
+
+tensor_index_select_lt
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_select_lt = cast3 Unmanaged.tensor_index_select_lt
+
+tensor_index_select_nt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_index_select_nt = cast3 Unmanaged.tensor_index_select_nt
+
+tensor_masked_select_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_masked_select_t = cast2 Unmanaged.tensor_masked_select_t
+
+tensor_nonzero
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_nonzero = cast1 Unmanaged.tensor_nonzero
+
+tensor_nonzero_numpy
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr TensorList)
+tensor_nonzero_numpy = cast1 Unmanaged.tensor_nonzero_numpy
+
+tensor_argwhere
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_argwhere = cast1 Unmanaged.tensor_argwhere
+
+tensor_gather_ltb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_gather_ltb = cast4 Unmanaged.tensor_gather_ltb
+
+tensor_gather_ntb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_gather_ntb = cast4 Unmanaged.tensor_gather_ntb
+
+tensor_addcmul_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addcmul_tts = cast4 Unmanaged.tensor_addcmul_tts
+
+tensor_addcmul__tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addcmul__tts = cast4 Unmanaged.tensor_addcmul__tts
+
+tensor_addcdiv_tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addcdiv_tts = cast4 Unmanaged.tensor_addcdiv_tts
+
+tensor_addcdiv__tts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_addcdiv__tts = cast4 Unmanaged.tensor_addcdiv__tts
+
+tensor_triangular_solve_tbbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_triangular_solve_tbbb = cast5 Unmanaged.tensor_triangular_solve_tbbb
+
+tensor_svd_bb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor)))
+tensor_svd_bb = cast3 Unmanaged.tensor_svd_bb
+
+tensor_swapaxes_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_swapaxes_ll = cast3 Unmanaged.tensor_swapaxes_ll
+
+tensor_swapaxes__ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_swapaxes__ll = cast3 Unmanaged.tensor_swapaxes__ll
+
+tensor_swapdims_ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_swapdims_ll = cast3 Unmanaged.tensor_swapdims_ll
+
+tensor_swapdims__ll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_swapdims__ll = cast3 Unmanaged.tensor_swapdims__ll
+
+tensor_cholesky_b
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_cholesky_b = cast2 Unmanaged.tensor_cholesky_b
+
+tensor_cholesky_solve_tb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_cholesky_solve_tb = cast3 Unmanaged.tensor_cholesky_solve_tb
+
+tensor_cholesky_inverse_b
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_cholesky_inverse_b = cast2 Unmanaged.tensor_cholesky_inverse_b
+
+tensor_qr_b
+  :: ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_qr_b = cast2 Unmanaged.tensor_qr_b
+
+tensor_geqrf
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_geqrf = cast1 Unmanaged.tensor_geqrf
+
+tensor_orgqr_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_orgqr_t = cast2 Unmanaged.tensor_orgqr_t
+
+tensor_ormqr_ttbb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_ormqr_ttbb = cast5 Unmanaged.tensor_ormqr_ttbb
+
+tensor_lu_solve_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lu_solve_tt = cast3 Unmanaged.tensor_lu_solve_tt
+
+tensor_multinomial_lbG
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_multinomial_lbG = cast4 Unmanaged.tensor_multinomial_lbG
+
+tensor_lgamma_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lgamma_ = cast1 Unmanaged.tensor_lgamma_
+
+tensor_lgamma
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lgamma = cast1 Unmanaged.tensor_lgamma
+
+tensor_digamma
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_digamma = cast1 Unmanaged.tensor_digamma
+
+tensor_polygamma__l
+  :: ForeignPtr Tensor
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_polygamma__l = cast2 Unmanaged.tensor_polygamma__l
+
+tensor_erfinv
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_erfinv = cast1 Unmanaged.tensor_erfinv
+
+tensor_erfinv_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_erfinv_ = cast1 Unmanaged.tensor_erfinv_
+
+tensor_i0
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_i0 = cast1 Unmanaged.tensor_i0
+
+tensor_i0_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_i0_ = cast1 Unmanaged.tensor_i0_
+
+tensor_sign
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sign = cast1 Unmanaged.tensor_sign
+
+tensor_sign_
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_sign_ = cast1 Unmanaged.tensor_sign_
+
+tensor_signbit
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_signbit = cast1 Unmanaged.tensor_signbit
+
+tensor_dist_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_dist_ts = cast3 Unmanaged.tensor_dist_ts
+
+tensor_atan2__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_atan2__t = cast2 Unmanaged.tensor_atan2__t
+
+tensor_atan2_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_atan2_t = cast2 Unmanaged.tensor_atan2_t
+
+tensor_arctan2_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arctan2_t = cast2 Unmanaged.tensor_arctan2_t
+
+tensor_arctan2__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_arctan2__t = cast2 Unmanaged.tensor_arctan2__t
+
+tensor_lerp_ts
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_lerp_ts = cast3 Unmanaged.tensor_lerp_ts
+
+tensor_lerp_tt
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_lerp_tt = cast3 Unmanaged.tensor_lerp_tt
+
+tensor_histc_lss
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr Scalar
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_histc_lss = cast4 Unmanaged.tensor_histc_lss
+
+tensor_histogram_ttb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_histogram_ttb = cast4 Unmanaged.tensor_histogram_ttb
+
+tensor_histogram_latb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> ForeignPtr (StdVector CDouble)
+  -> ForeignPtr Tensor
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_histogram_latb = cast5 Unmanaged.tensor_histogram_latb
+
+tensor_fmod_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_fmod_s = cast2 Unmanaged.tensor_fmod_s
+
+tensor_fmod__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_fmod__s = cast2 Unmanaged.tensor_fmod__s
+
+tensor_fmod_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_fmod_t = cast2 Unmanaged.tensor_fmod_t
+
+tensor_fmod__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_fmod__t = cast2 Unmanaged.tensor_fmod__t
+
+tensor_hypot_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_hypot_t = cast2 Unmanaged.tensor_hypot_t
+
+tensor_hypot__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_hypot__t = cast2 Unmanaged.tensor_hypot__t
+
+tensor_igamma_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_igamma_t = cast2 Unmanaged.tensor_igamma_t
+
+tensor_igamma__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_igamma__t = cast2 Unmanaged.tensor_igamma__t
+
+tensor_igammac_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_igammac_t = cast2 Unmanaged.tensor_igammac_t
+
+tensor_igammac__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_igammac__t = cast2 Unmanaged.tensor_igammac__t
+
+tensor_nextafter_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_nextafter_t = cast2 Unmanaged.tensor_nextafter_t
+
+tensor_nextafter__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_nextafter__t = cast2 Unmanaged.tensor_nextafter__t
+
+tensor_remainder_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_remainder_s = cast2 Unmanaged.tensor_remainder_s
+
+tensor_remainder__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_remainder__s = cast2 Unmanaged.tensor_remainder__s
+
+tensor_remainder_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_remainder_t = cast2 Unmanaged.tensor_remainder_t
+
+tensor_remainder__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_remainder__t = cast2 Unmanaged.tensor_remainder__t
+
+tensor_min
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_min = cast1 Unmanaged.tensor_min
+
+tensor_fmin_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_fmin_t = cast2 Unmanaged.tensor_fmin_t
+
+tensor_max
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_max = cast1 Unmanaged.tensor_max
+
+tensor_fmax_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_fmax_t = cast2 Unmanaged.tensor_fmax_t
+
+tensor_maximum_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_maximum_t = cast2 Unmanaged.tensor_maximum_t
+
+tensor_max_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_max_t = cast2 Unmanaged.tensor_max_t
+
+tensor_minimum_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_minimum_t = cast2 Unmanaged.tensor_minimum_t
+
+tensor_min_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_min_t = cast2 Unmanaged.tensor_min_t
+
+tensor_quantile_tlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_quantile_tlbs = cast5 Unmanaged.tensor_quantile_tlbs
+
+tensor_quantile_dlbs
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_quantile_dlbs = cast5 Unmanaged.tensor_quantile_dlbs
+
+tensor_nanquantile_tlbs
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_nanquantile_tlbs = cast5 Unmanaged.tensor_nanquantile_tlbs
+
+tensor_nanquantile_dlbs
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> ForeignPtr StdString
+  -> IO (ForeignPtr Tensor)
+tensor_nanquantile_dlbs = cast5 Unmanaged.tensor_nanquantile_dlbs
+
+tensor_sort_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_sort_lb = cast3 Unmanaged.tensor_sort_lb
+
+tensor_sort_blb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_sort_blb = cast4 Unmanaged.tensor_sort_blb
+
+tensor_sort_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_sort_nb = cast3 Unmanaged.tensor_sort_nb
+
+tensor_sort_bnb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_sort_bnb = cast4 Unmanaged.tensor_sort_bnb
+
+tensor_msort
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_msort = cast1 Unmanaged.tensor_msort
+
+tensor_argsort_lb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_argsort_lb = cast3 Unmanaged.tensor_argsort_lb
+
+tensor_argsort_blb
+  :: ForeignPtr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_argsort_blb = cast4 Unmanaged.tensor_argsort_blb
+
+tensor_argsort_nb
+  :: ForeignPtr Tensor
+  -> ForeignPtr Dimname
+  -> CBool
+  -> IO (ForeignPtr Tensor)
+tensor_argsort_nb = cast3 Unmanaged.tensor_argsort_nb
+
+tensor_topk_llbb
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_topk_llbb = cast5 Unmanaged.tensor_topk_llbb
+
+tensor_all
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_all = cast1 Unmanaged.tensor_all
+
+tensor_any
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_any = cast1 Unmanaged.tensor_any
+
+tensor_renorm_sls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> Int64
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_renorm_sls = cast4 Unmanaged.tensor_renorm_sls
+
+tensor_renorm__sls
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> Int64
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_renorm__sls = cast4 Unmanaged.tensor_renorm__sls
+
+tensor_unfold_lll
+  :: ForeignPtr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (ForeignPtr Tensor)
+tensor_unfold_lll = cast4 Unmanaged.tensor_unfold_lll
+
+tensor_equal_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (CBool)
+tensor_equal_t = cast2 Unmanaged.tensor_equal_t
+
+tensor_pow_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_pow_t = cast2 Unmanaged.tensor_pow_t
+
+tensor_pow_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_pow_s = cast2 Unmanaged.tensor_pow_s
+
+tensor_pow__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_pow__s = cast2 Unmanaged.tensor_pow__s
+
+tensor_pow__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_pow__t = cast2 Unmanaged.tensor_pow__t
+
+tensor_float_power_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_float_power_t = cast2 Unmanaged.tensor_float_power_t
+
+tensor_float_power_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_float_power_s = cast2 Unmanaged.tensor_float_power_s
+
+tensor_float_power__s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Scalar
+  -> IO (ForeignPtr Tensor)
+tensor_float_power__s = cast2 Unmanaged.tensor_float_power__s
+
+tensor_float_power__t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_float_power__t = cast2 Unmanaged.tensor_float_power__t
+
+tensor_normal__ddG
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> CDouble
+  -> ForeignPtr Generator
+  -> IO (ForeignPtr Tensor)
+tensor_normal__ddG = cast4 Unmanaged.tensor_normal__ddG
+
+tensor_alias
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_alias = cast1 Unmanaged.tensor_alias
+
+tensor_isfinite
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_isfinite = cast1 Unmanaged.tensor_isfinite
+
+tensor_isinf
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_isinf = cast1 Unmanaged.tensor_isinf
+
+tensor_record_stream_s
+  :: ForeignPtr Tensor
+  -> ForeignPtr Stream
+  -> IO (())
+tensor_record_stream_s = cast2 Unmanaged.tensor_record_stream_s
+
+tensor_isposinf
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_isposinf = cast1 Unmanaged.tensor_isposinf
+
+tensor_isneginf
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_isneginf = cast1 Unmanaged.tensor_isneginf
+
+tensor_det
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_det = cast1 Unmanaged.tensor_det
+
+tensor_slogdet
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+tensor_slogdet = cast1 Unmanaged.tensor_slogdet
+
+tensor_logdet
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_logdet = cast1 Unmanaged.tensor_logdet
+
+tensor_inverse
+  :: ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_inverse = cast1 Unmanaged.tensor_inverse
+
+tensor_inner_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_inner_t = cast2 Unmanaged.tensor_inner_t
+
+tensor_outer_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_outer_t = cast2 Unmanaged.tensor_outer_t
+
+tensor_ger_t
+  :: ForeignPtr Tensor
+  -> ForeignPtr Tensor
+  -> IO (ForeignPtr Tensor)
+tensor_ger_t = cast2 Unmanaged.tensor_ger_t
+
+tensor_to_padded_tensor_dl
+  :: ForeignPtr Tensor
+  -> CDouble
+  -> ForeignPtr IntArray
+  -> IO (ForeignPtr Tensor)
+tensor_to_padded_tensor_dl = cast3 Unmanaged.tensor_to_padded_tensor_dl
+
diff --git a/src/Torch/Internal/Managed/Type/TensorIndex.hs b/src/Torch/Internal/Managed/Type/TensorIndex.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/TensorIndex.hs
@@ -0,0 +1,59 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.TensorIndex where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+
+import qualified Torch.Internal.Unmanaged.Type.TensorIndex as Unmanaged
+
+
+newTensorIndexList :: IO (ForeignPtr (StdVector TensorIndex))
+newTensorIndexList = _cast0 Unmanaged.newTensorIndexList
+
+newTensorIndexWithInt :: CInt -> IO (ForeignPtr TensorIndex)
+newTensorIndexWithInt = _cast1 Unmanaged.newTensorIndexWithInt
+
+newTensorIndexWithBool :: CBool -> IO (ForeignPtr TensorIndex)
+newTensorIndexWithBool = _cast1 Unmanaged.newTensorIndexWithBool
+
+newTensorIndexWithSlice :: CInt -> CInt -> CInt -> IO (ForeignPtr TensorIndex)
+newTensorIndexWithSlice = _cast3 Unmanaged.newTensorIndexWithSlice
+
+newTensorIndexWithTensor :: ForeignPtr Tensor -> IO (ForeignPtr TensorIndex)
+newTensorIndexWithTensor = _cast1 Unmanaged.newTensorIndexWithTensor
+
+newTensorIndexWithEllipsis :: IO (ForeignPtr TensorIndex)
+newTensorIndexWithEllipsis = _cast0 Unmanaged.newTensorIndexWithEllipsis
+
+newTensorIndexWithNone :: IO (ForeignPtr TensorIndex)
+newTensorIndexWithNone = _cast0 Unmanaged.newTensorIndexWithNone
+
+tensorIndexList_empty :: ForeignPtr (StdVector TensorIndex) -> IO (CBool)
+tensorIndexList_empty = _cast1 Unmanaged.tensorIndexList_empty
+
+tensorIndexList_size :: ForeignPtr (StdVector TensorIndex) -> IO (CSize)
+tensorIndexList_size = _cast1 Unmanaged.tensorIndexList_size
+
+tensorIndexList_push_back :: ForeignPtr (StdVector TensorIndex) -> ForeignPtr TensorIndex -> IO ()
+tensorIndexList_push_back = _cast2 Unmanaged.tensorIndexList_push_back
+
+index :: ForeignPtr Tensor -> ForeignPtr (StdVector TensorIndex) -> IO (ForeignPtr Tensor)
+index = _cast2 Unmanaged.index
+
+index_put_ :: ForeignPtr Tensor -> ForeignPtr (StdVector TensorIndex) -> ForeignPtr Tensor -> IO (ForeignPtr Tensor)
+index_put_ = _cast3 Unmanaged.index_put_
diff --git a/src/Torch/Internal/Managed/Type/TensorList.hs b/src/Torch/Internal/Managed/Type/TensorList.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/TensorList.hs
@@ -0,0 +1,52 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.TensorList where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.TensorList as Unmanaged
+
+
+
+
+
+newTensorList
+  :: IO (ForeignPtr TensorList)
+newTensorList = _cast0 Unmanaged.newTensorList
+
+tensorList_empty
+  :: ForeignPtr TensorList
+  -> IO (CBool)
+tensorList_empty = _cast1 Unmanaged.tensorList_empty
+
+tensorList_size
+  :: ForeignPtr TensorList
+  -> IO (CSize)
+tensorList_size = _cast1 Unmanaged.tensorList_size
+
+tensorList_at_s
+  :: ForeignPtr TensorList
+  -> CSize
+  -> IO (ForeignPtr Tensor)
+tensorList_at_s = _cast2 Unmanaged.tensorList_at_s
+
+tensorList_push_back_t
+  :: ForeignPtr TensorList
+  -> ForeignPtr Tensor
+  -> IO (())
+tensorList_push_back_t = _cast2 Unmanaged.tensorList_push_back_t
+
diff --git a/src/Torch/Internal/Managed/Type/TensorOptions.hs b/src/Torch/Internal/Managed/Type/TensorOptions.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/TensorOptions.hs
@@ -0,0 +1,131 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.TensorOptions where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.TensorOptions as Unmanaged
+
+
+
+
+
+newTensorOptions_s
+  :: ScalarType
+  -> IO (ForeignPtr TensorOptions)
+newTensorOptions_s = _cast1 Unmanaged.newTensorOptions_s
+
+tensorOptions_device_D
+  :: ForeignPtr TensorOptions
+  -> DeviceType
+  -> IO (ForeignPtr TensorOptions)
+tensorOptions_device_D = _cast2 Unmanaged.tensorOptions_device_D
+
+tensorOptions_device_index_s
+  :: ForeignPtr TensorOptions
+  -> Int16
+  -> IO (ForeignPtr TensorOptions)
+tensorOptions_device_index_s = _cast2 Unmanaged.tensorOptions_device_index_s
+
+tensorOptions_dtype_s
+  :: ForeignPtr TensorOptions
+  -> ScalarType
+  -> IO (ForeignPtr TensorOptions)
+tensorOptions_dtype_s = _cast2 Unmanaged.tensorOptions_dtype_s
+
+tensorOptions_dtype
+  :: ForeignPtr TensorOptions
+  -> IO (ForeignPtr TensorOptions)
+tensorOptions_dtype = _cast1 Unmanaged.tensorOptions_dtype
+
+tensorOptions_layout_L
+  :: ForeignPtr TensorOptions
+  -> Layout
+  -> IO (ForeignPtr TensorOptions)
+tensorOptions_layout_L = _cast2 Unmanaged.tensorOptions_layout_L
+
+tensorOptions_requires_grad_b
+  :: ForeignPtr TensorOptions
+  -> CBool
+  -> IO (ForeignPtr TensorOptions)
+tensorOptions_requires_grad_b = _cast2 Unmanaged.tensorOptions_requires_grad_b
+
+tensorOptions_has_device
+  :: ForeignPtr TensorOptions
+  -> IO (CBool)
+tensorOptions_has_device = _cast1 Unmanaged.tensorOptions_has_device
+
+tensorOptions_device_index
+  :: ForeignPtr TensorOptions
+  -> IO (Int32)
+tensorOptions_device_index = _cast1 Unmanaged.tensorOptions_device_index
+
+tensorOptions_has_dtype
+  :: ForeignPtr TensorOptions
+  -> IO (CBool)
+tensorOptions_has_dtype = _cast1 Unmanaged.tensorOptions_has_dtype
+
+tensorOptions_layout
+  :: ForeignPtr TensorOptions
+  -> IO (Layout)
+tensorOptions_layout = _cast1 Unmanaged.tensorOptions_layout
+
+tensorOptions_has_layout
+  :: ForeignPtr TensorOptions
+  -> IO (CBool)
+tensorOptions_has_layout = _cast1 Unmanaged.tensorOptions_has_layout
+
+tensorOptions_requires_grad
+  :: ForeignPtr TensorOptions
+  -> IO (CBool)
+tensorOptions_requires_grad = _cast1 Unmanaged.tensorOptions_requires_grad
+
+tensorOptions_has_requires_grad
+  :: ForeignPtr TensorOptions
+  -> IO (CBool)
+tensorOptions_has_requires_grad = _cast1 Unmanaged.tensorOptions_has_requires_grad
+
+tensorOptions_backend
+  :: ForeignPtr TensorOptions
+  -> IO (Backend)
+tensorOptions_backend = _cast1 Unmanaged.tensorOptions_backend
+
+dtype_s
+  :: ScalarType
+  -> IO (ForeignPtr TensorOptions)
+dtype_s = _cast1 Unmanaged.dtype_s
+
+layout_L
+  :: Layout
+  -> IO (ForeignPtr TensorOptions)
+layout_L = _cast1 Unmanaged.layout_L
+
+device_D
+  :: DeviceType
+  -> IO (ForeignPtr TensorOptions)
+device_D = _cast1 Unmanaged.device_D
+
+device_index_s
+  :: Int16
+  -> IO (ForeignPtr TensorOptions)
+device_index_s = _cast1 Unmanaged.device_index_s
+
+requires_grad_b
+  :: CBool
+  -> IO (ForeignPtr TensorOptions)
+requires_grad_b = _cast1 Unmanaged.requires_grad_b
+
diff --git a/src/Torch/Internal/Managed/Type/Tuple.hs b/src/Torch/Internal/Managed/Type/Tuple.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Managed/Type/Tuple.hs
@@ -0,0 +1,275 @@
+
+-- generated by using spec/tuples.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Managed.Type.Tuple where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Cast
+import Torch.Internal.Objects
+import qualified Torch.Internal.Unmanaged.Type.Tuple as Unmanaged
+
+
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple5 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type E (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get4 v = cast1 (get4 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) = ForeignPtr Tensor
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)) -> IO (Ptr Tensor)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) = ForeignPtr TensorList
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)) -> IO (Ptr TensorList)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = ForeignPtr Tensor
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)) -> IO (Ptr Tensor)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = ForeignPtr Tensor
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)) -> IO (Ptr Tensor)) v
+
+instance CppTuple5 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) where
+  type E (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = Int64
+  get4 v = cast1 (get4 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)) -> IO (Int64)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,CDouble,Int64))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,CDouble,Int64))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,CDouble,Int64))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,CDouble,Int64))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,CDouble,Int64))) = CDouble
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64)) -> IO (CDouble)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,CDouble,Int64))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,CDouble,Int64))) = Int64
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64)) -> IO (Int64)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple5 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type E (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get4 v = cast1 (get4 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple6 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type F (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get5 v = cast1 (get5 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple7 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type G (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get6 v = cast1 (get6 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(CDouble,Int64))) where
+  type A (ForeignPtr (StdTuple '(CDouble,Int64))) = CDouble
+  type B (ForeignPtr (StdTuple '(CDouble,Int64))) = Int64
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(CDouble,Int64)) -> IO (CDouble)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(CDouble,Int64)) -> IO (Int64)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple5 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type E (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get4 v = cast1 (get4 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple6 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type F (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = ForeignPtr Tensor
+  get5 v = cast1 (get5 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,TensorList,TensorList))) where
+  type A (ForeignPtr (StdTuple '(Tensor,TensorList,TensorList))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,TensorList,TensorList))) = ForeignPtr TensorList
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,TensorList,TensorList)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,TensorList,TensorList)) -> IO (Ptr TensorList)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,TensorList,TensorList))) where
+  type C (ForeignPtr (StdTuple '(Tensor,TensorList,TensorList))) = ForeignPtr TensorList
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,TensorList,TensorList)) -> IO (Ptr TensorList)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,TensorList))) where
+  type A (ForeignPtr (StdTuple '(Tensor,TensorList))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,TensorList))) = ForeignPtr TensorList
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,TensorList)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,TensorList)) -> IO (Ptr TensorList)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = ForeignPtr Tensor
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = ForeignPtr Tensor
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple5 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type E (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Int64
+  get4 v = cast1 (get4 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Int64)) v
+
+instance CppTuple6 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type F (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Int64
+  get5 v = cast1 (get5 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Int64)) v
+
+instance CppTuple7 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type G (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Int64
+  get6 v = cast1 (get6 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Int64)) v
+
+instance CppTuple8 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type H (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Int64
+  get7 v = cast1 (get7 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Int64)) v
+
+instance CppTuple9 (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type I (ForeignPtr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = ForeignPtr Tensor
+  get8 v = cast1 (get8 :: Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)) -> IO (Ptr Tensor)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) where
+  type C (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = Int64
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)) -> IO (Int64)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) where
+  type D (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = Int64
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)) -> IO (Int64)) v
+
+instance CppTuple5 (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) where
+  type E (ForeignPtr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = ForeignPtr Tensor
+  get4 v = cast1 (get4 :: Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(TensorList,Tensor))) where
+  type A (ForeignPtr (StdTuple '(TensorList,Tensor))) = ForeignPtr TensorList
+  type B (ForeignPtr (StdTuple '(TensorList,Tensor))) = ForeignPtr Tensor
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(TensorList,Tensor)) -> IO (Ptr TensorList)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(TensorList,Tensor)) -> IO (Ptr Tensor)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) where
+  type A (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = ForeignPtr TensorList
+  type B (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = ForeignPtr TensorList
+  get0 v = cast1 (get0 :: Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)) -> IO (Ptr TensorList)) v
+  get1 v = cast1 (get1 :: Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)) -> IO (Ptr TensorList)) v
+
+instance CppTuple3 (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) where
+  type C (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = ForeignPtr TensorList
+  get2 v = cast1 (get2 :: Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)) -> IO (Ptr TensorList)) v
+
+instance CppTuple4 (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) where
+  type D (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = ForeignPtr TensorList
+  get3 v = cast1 (get3 :: Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)) -> IO (Ptr TensorList)) v
+
+instance CppTuple5 (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) where
+  type E (ForeignPtr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = ForeignPtr TensorList
+  get4 v = cast1 (get4 :: Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)) -> IO (Ptr TensorList)) v
+
+instance CppTuple2 (ForeignPtr (StdTuple '(Tensor,Generator))) where
+  type A (ForeignPtr (StdTuple '(Tensor,Generator))) = ForeignPtr Tensor
+  type B (ForeignPtr (StdTuple '(Tensor,Generator))) = ForeignPtr Generator
+  get0 v = _cast1 (get0 :: Ptr (StdTuple '(Tensor,Generator)) -> IO (Ptr Tensor)) v
+  get1 v = _cast1 (get1 :: Ptr (StdTuple '(Tensor,Generator)) -> IO (Ptr Generator)) v
+  makeTuple2 (a,b) =
+    withForeignPtr a $ \a' -> do
+    withForeignPtr b $ \b' -> do
+      fromPtr =<< makeTuple2 (a',b')
diff --git a/src/Torch/Internal/Objects.hs b/src/Torch/Internal/Objects.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Objects.hs
@@ -0,0 +1,695 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Objects where
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+
+
+import Torch.Internal.Type
+import Torch.Internal.Class
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_c10dict"
+  c_delete_c10dict  :: FunPtr( Ptr (C10Dict '(IValue,IValue)) -> IO () )
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_c10dict"
+  c_delete_c10dict'  :: Ptr (C10Dict '(IValue,IValue)) -> IO ()
+
+instance CppObject (C10Dict '(IValue,IValue)) where
+  fromPtr ptr = newForeignPtr c_delete_c10dict ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_c10dict' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_c10listivalue"
+  c_delete_c10listivalue :: FunPtr ( Ptr (C10List IValue) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_c10listivalue"
+  c_delete_c10listivalue' ::  Ptr (C10List IValue) -> IO ()
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_c10listtensor"
+  c_delete_c10listtensor :: FunPtr ( Ptr (C10List Tensor) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_c10listtensor"
+  c_delete_c10listtensor' ::  Ptr (C10List Tensor) -> IO ()
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_c10listoptionaltensor"
+  c_delete_c10listoptionaltensor :: FunPtr ( Ptr (C10List (C10Optional Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_c10listoptionaltensor"
+  c_delete_c10listoptionaltensor' ::  Ptr (C10List (C10Optional Tensor)) -> IO ()
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_c10listdouble"
+  c_delete_c10listdouble :: FunPtr ( Ptr (C10List CDouble) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_c10listdouble"
+  c_delete_c10listdouble' ::  Ptr (C10List CDouble) -> IO ()
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_c10listint"
+  c_delete_c10listint :: FunPtr ( Ptr (C10List Int64) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_c10listint"
+  c_delete_c10listint' ::  Ptr (C10List Int64) -> IO ()
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_c10listbool"
+  c_delete_c10listbool :: FunPtr ( Ptr (C10List CBool) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_c10listbool"
+  c_delete_c10listbool' ::  Ptr (C10List CBool) -> IO ()
+
+instance CppObject (C10List IValue) where
+  fromPtr ptr = newForeignPtr c_delete_c10listivalue ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_c10listivalue' ptr
+  {-# INLINE deletePtr #-}
+
+instance CppObject (C10List Tensor) where
+  fromPtr ptr = newForeignPtr c_delete_c10listtensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_c10listtensor' ptr
+  {-# INLINE deletePtr #-}
+
+instance CppObject (C10List (C10Optional Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_c10listoptionaltensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_c10listoptionaltensor' ptr
+  {-# INLINE deletePtr #-}
+
+instance CppObject (C10List CDouble) where
+  fromPtr ptr = newForeignPtr c_delete_c10listdouble ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_c10listdouble' ptr
+  {-# INLINE deletePtr #-}
+
+instance CppObject (C10List Int64) where
+  fromPtr ptr = newForeignPtr c_delete_c10listint ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_c10listint' ptr
+  {-# INLINE deletePtr #-}
+
+instance CppObject (C10List CBool) where
+  fromPtr ptr = newForeignPtr c_delete_c10listbool ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_c10listbool' ptr
+  {-# INLINE deletePtr #-}
+
+
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_c10tuple"
+  c_delete_c10tuple :: FunPtr ( Ptr (C10Ptr IVTuple) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_c10tuple"
+  c_delete_c10tuple' ::  Ptr (C10Ptr IVTuple) -> IO ()
+
+instance CppObject (C10Ptr IVTuple) where
+  fromPtr ptr = newForeignPtr c_delete_c10tuple ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_c10tuple' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_context"
+  c_delete_context :: FunPtr ( Ptr Context -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_context"
+  c_delete_context' ::  Ptr Context -> IO ()
+
+instance CppObject Context where
+  fromPtr ptr = newForeignPtr c_delete_context ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_context' ptr
+  {-# INLINE deletePtr #-}
+
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_dimname"
+  c_delete_dimname :: FunPtr ( Ptr Dimname -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_dimname"
+  c_delete_dimname' ::  Ptr Dimname -> IO ()
+
+instance CppObject Dimname where
+  fromPtr ptr = newForeignPtr c_delete_dimname ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_dimname' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_dimnamelist"
+  c_delete_dimnamelist :: FunPtr ( Ptr DimnameList -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_dimnamelist"
+  c_delete_dimnamelist' ::  Ptr DimnameList -> IO ()
+
+instance CppObject DimnameList where
+  fromPtr ptr = newForeignPtr c_delete_dimnamelist ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_dimnamelist' ptr
+  {-# INLINE deletePtr #-}
+
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_generator"
+  c_delete_generator :: FunPtr ( Ptr Generator -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_generator"
+  c_delete_generator' ::  Ptr Generator -> IO ()
+
+instance CppObject Generator where
+  fromPtr ptr = newForeignPtr c_delete_generator ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_generator' ptr
+  {-# INLINE deletePtr #-}
+
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_ivalue"
+  c_delete_ivalue :: FunPtr ( Ptr IValue -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_ivalue"
+  c_delete_ivalue' ::  Ptr IValue -> IO ()
+
+instance CppObject IValue where
+  fromPtr ptr = newForeignPtr c_delete_ivalue ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_ivalue' ptr
+  {-# INLINE deletePtr #-}
+
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_ivaluelist"
+  c_delete_ivaluelist :: FunPtr ( Ptr IValueList -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_ivaluelist"
+  c_delete_ivaluelist' ::  Ptr IValueList -> IO ()
+
+instance CppObject IValueList where
+  fromPtr ptr = newForeignPtr c_delete_ivaluelist ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_ivaluelist' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_intarray"
+  c_delete_intarray :: FunPtr ( Ptr IntArray -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_intarray"
+  c_delete_intarray' ::  Ptr IntArray -> IO ()
+
+instance CppObject IntArray where
+  fromPtr ptr = newForeignPtr c_delete_intarray ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_intarray' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_module"
+  c_delete_module :: FunPtr ( Ptr Module -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_module"
+  c_delete_module' ::  Ptr Module -> IO ()
+
+instance CppObject Module where
+  fromPtr ptr = newForeignPtr c_delete_module ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_module' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_jitgraph"
+  c_delete_jitgraph :: FunPtr ( Ptr (SharedPtr JitGraph) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_jitgraph"
+  c_delete_jitgraph' ::  Ptr (SharedPtr JitGraph) -> IO ()
+
+instance CppObject (SharedPtr JitGraph) where
+  fromPtr ptr = newForeignPtr c_delete_jitgraph ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_jitgraph' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_jitnode"
+  c_delete_jitnode :: FunPtr ( Ptr JitNode -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_jitnode"
+  c_delete_jitnode' ::  Ptr JitNode -> IO ()
+
+instance CppObject JitNode where
+  fromPtr ptr = newForeignPtr c_delete_jitnode ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_jitnode' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_jitvalue"
+  c_delete_jitvalue :: FunPtr ( Ptr JitValue -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_jitvalue"
+  c_delete_jitvalue' ::  Ptr JitValue -> IO ()
+
+instance CppObject JitValue where
+  fromPtr ptr = newForeignPtr c_delete_jitvalue ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_jitvalue' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_scalar"
+  c_delete_scalar :: FunPtr ( Ptr Scalar -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_scalar"
+  c_delete_scalar' ::  Ptr Scalar -> IO ()
+
+instance CppObject Scalar where
+  fromPtr ptr = newForeignPtr c_delete_scalar ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_scalar' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_stdarraybool2"
+  c_delete_stdarraybool2 :: FunPtr ( Ptr (StdArray '(CBool,2)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_stdarraybool2"
+  c_delete_stdarraybool2' ::  Ptr (StdArray '(CBool,2)) -> IO ()
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_stdarraybool3"
+  c_delete_stdarraybool3 :: FunPtr ( Ptr (StdArray '(CBool,3)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_stdarraybool3"
+  c_delete_stdarraybool3' ::  Ptr (StdArray '(CBool,3)) -> IO ()
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_stdarraybool4"
+  c_delete_stdarraybool4 :: FunPtr ( Ptr (StdArray '(CBool,4)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_stdarraybool4"
+  c_delete_stdarraybool4' ::  Ptr (StdArray '(CBool,4)) -> IO ()
+
+instance CppObject (StdArray '(CBool,2)) where
+  fromPtr ptr = newForeignPtr c_delete_stdarraybool2 ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_stdarraybool2' ptr
+  {-# INLINE deletePtr #-}
+
+instance CppObject (StdArray '(CBool,3)) where
+  fromPtr ptr = newForeignPtr c_delete_stdarraybool3 ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_stdarraybool3' ptr
+  {-# INLINE deletePtr #-}
+
+instance CppObject (StdArray '(CBool,4)) where
+  fromPtr ptr = newForeignPtr c_delete_stdarraybool4 ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_stdarraybool4' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_stdstring"
+  c_delete_stdstring :: FunPtr ( Ptr StdString -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_stdstring"
+  c_delete_stdstring' ::  Ptr StdString -> IO ()
+
+instance CppObject StdString where
+  fromPtr ptr = newForeignPtr c_delete_stdstring ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_stdstring' ptr
+  {-# INLINE deletePtr #-}
+
+
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_storage"
+  c_delete_storage :: FunPtr ( Ptr Storage -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_storage"
+  c_delete_storage' ::  Ptr Storage -> IO ()
+
+instance CppObject Storage where
+  fromPtr ptr = newForeignPtr c_delete_storage ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_storage' ptr
+  {-# INLINE deletePtr #-}
+
+
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_symbol"
+  c_delete_symbol :: FunPtr ( Ptr Symbol -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_symbol"
+  c_delete_symbol' ::  Ptr Symbol -> IO ()
+
+instance CppObject Symbol where
+  fromPtr ptr = newForeignPtr c_delete_symbol ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_symbol' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensor"
+  c_delete_tensor  :: FunPtr( Ptr Tensor -> IO () )
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensor"
+  c_delete_tensor' :: Ptr Tensor -> IO () 
+
+instance CppObject Tensor where
+  fromPtr ptr = newForeignPtr c_delete_tensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensorindex"
+  c_delete_tensorindex :: FunPtr ( Ptr TensorIndex -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensorindex"
+  c_delete_tensorindex' ::  Ptr TensorIndex -> IO ()
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensorindexlist"
+  c_delete_tensorindexlist :: FunPtr ( Ptr (StdVector TensorIndex) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensorindexlist"
+  c_delete_tensorindexlist' ::  Ptr (StdVector TensorIndex) -> IO ()
+
+instance CppObject TensorIndex where
+  fromPtr ptr = newForeignPtr c_delete_tensorindex ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensorindex' ptr
+  {-# INLINE deletePtr #-}
+
+instance CppObject (StdVector TensorIndex) where
+  fromPtr ptr = newForeignPtr c_delete_tensorindexlist ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensorindexlist' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensorlist"
+  c_delete_tensorlist :: FunPtr ( Ptr TensorList -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensorlist"
+  c_delete_tensorlist' ::  Ptr TensorList -> IO ()
+
+instance CppObject TensorList where
+  fromPtr ptr = newForeignPtr c_delete_tensorlist ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensorlist' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensoroptions"
+  c_delete_tensoroptions :: FunPtr ( Ptr TensorOptions -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensoroptions"
+  c_delete_tensoroptions' ::  Ptr TensorOptions -> IO ()
+
+instance CppObject TensorOptions where
+  fromPtr ptr = newForeignPtr c_delete_tensoroptions ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensoroptions' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensor"
+  c_delete_tensortensor :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensor"
+  c_delete_tensortensor' ::  Ptr (StdTuple '(Tensor,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensortensortensortensor"
+  c_delete_tensortensortensortensortensor :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensortensortensortensor"
+  c_delete_tensortensortensortensortensor' ::  Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensortensortensortensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensortensortensortensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensortensortensorlist"
+  c_delete_tensortensortensortensorlist :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensortensortensorlist"
+  c_delete_tensortensortensortensorlist' ::  Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Tensor,TensorList)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensortensortensorlist ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensortensortensorlist' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensortensortensorint64"
+  c_delete_tensortensortensortensorint64 :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensortensortensorint64"
+  c_delete_tensortensortensortensorint64' ::  Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensortensortensorint64 ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensortensortensorint64' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensortensor"
+  c_delete_tensortensortensor :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensortensor"
+  c_delete_tensortensortensor' ::  Ptr (StdTuple '(Tensor,Tensor,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensortensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensortensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensortensortensor"
+  c_delete_tensortensortensortensor :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensortensortensor"
+  c_delete_tensortensortensortensor' ::  Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Tensor,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensortensortensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensortensortensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_cdoubleint64"
+  c_delete_cdoubleint64 :: FunPtr ( Ptr (StdTuple '(CDouble,Int64)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_cdoubleint64"
+  c_delete_cdoubleint64' ::  Ptr (StdTuple '(CDouble,Int64)) -> IO ()
+
+instance CppObject (StdTuple '(CDouble,Int64)) where
+  fromPtr ptr = newForeignPtr c_delete_cdoubleint64 ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_cdoubleint64' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_cdoublecdouble"
+  c_delete_cdoublecdouble :: FunPtr ( Ptr (StdTuple '(CDouble,CDouble)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_cdoublecdouble"
+  c_delete_cdoublecdouble' ::  Ptr (StdTuple '(CDouble,CDouble)) -> IO ()
+
+instance CppObject (StdTuple '(CDouble,CDouble)) where
+  fromPtr ptr = newForeignPtr c_delete_cdoublecdouble ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_cdoublecdouble' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensorgenerator"
+  c_delete_tensorgenerator :: FunPtr ( Ptr (StdTuple '(Tensor,Generator)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensorgenerator"
+  c_delete_tensorgenerator' ::  Ptr (StdTuple '(Tensor,Generator)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Generator)) where
+  fromPtr ptr = newForeignPtr c_delete_tensorgenerator ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensorgenerator' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensorcdoubleint64"
+  c_delete_tensortensorcdoubleint64 :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensorcdoubleint64"
+  c_delete_tensortensorcdoubleint64' ::  Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,CDouble,Int64)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensorcdoubleint64 ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensorcdoubleint64' ptr
+  {-# INLINE deletePtr #-}
+
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensorint64int64tensor"
+  c_delete_tensortensorint64int64tensor :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensorint64int64tensor"
+  c_delete_tensortensorint64int64tensor' ::  Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensorint64int64tensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensorint64int64tensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensortensortensorint64int64int64int64tensor"
+  c_delete_tensortensortensortensorint64int64int64int64tensor :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensorint64int64tensor"
+  c_delete_tensortensortensortensorint64int64int64int64tensor' ::  Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensortensortensorint64int64int64int64tensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensortensortensorint64int64int64int64tensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensortensortensortensortensor"
+  c_delete_tensortensortensortensortensortensor :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensorint64int64tensor"
+  c_delete_tensortensortensortensortensortensor' ::  Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensortensortensortensortensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensortensortensortensortensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensortensortensortensortensortensor"
+  c_delete_tensortensortensortensortensortensortensor :: FunPtr ( Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensorint64int64tensortensor"
+  c_delete_tensortensortensortensortensortensortensor' ::  Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensortensortensortensortensortensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensortensortensortensortensortensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensorlisttensor"
+  c_delete_tensorlisttensor :: FunPtr ( Ptr (StdTuple '(TensorList,Tensor)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensorlisttensor"
+  c_delete_tensorlisttensor' ::  Ptr (StdTuple '(TensorList,Tensor)) -> IO ()
+
+instance CppObject (StdTuple '(TensorList,Tensor)) where
+  fromPtr ptr = newForeignPtr c_delete_tensorlisttensor ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensorlisttensor' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensorlist"
+  c_delete_tensortensorlist :: FunPtr ( Ptr (StdTuple '(Tensor,TensorList)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensorlist"
+  c_delete_tensortensorlist' ::  Ptr (StdTuple '(Tensor,TensorList)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,TensorList)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensorlist ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensorlist' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensortensorlisttensorlist"
+  c_delete_tensortensorlisttensorlist :: FunPtr ( Ptr (StdTuple '(Tensor,TensorList,TensorList)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensortensorlisttensorlist"
+  c_delete_tensortensorlisttensorlist' ::  Ptr (StdTuple '(Tensor,TensorList,TensorList)) -> IO ()
+
+instance CppObject (StdTuple '(Tensor,TensorList,TensorList)) where
+  fromPtr ptr = newForeignPtr c_delete_tensortensorlisttensorlist ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensortensorlisttensorlist' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_tensorlisttensorlisttensorlisttensorlisttensorlist"
+  c_delete_tensorlisttensorlisttensorlisttensorlisttensorlist :: FunPtr ( Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_tensorlisttensorlisttensorlisttensorlisttensorlist"
+  c_delete_tensorlisttensorlisttensorlisttensorlisttensorlist' ::  Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)) -> IO ()
+
+instance CppObject (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)) where
+  fromPtr ptr = newForeignPtr c_delete_tensorlisttensorlisttensorlisttensorlisttensorlist ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_tensorlisttensorlisttensorlisttensorlisttensorlist' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_optimizer"
+  c_delete_optimizer  :: FunPtr( Ptr Optimizer -> IO () )
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_optimizer"
+  c_delete_optimizer' :: Ptr Optimizer -> IO () 
+
+instance CppObject Optimizer where
+  fromPtr ptr = newForeignPtr c_delete_optimizer ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_optimizer' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_stdvectordouble"
+  c_delete_stdvectordouble :: FunPtr ( Ptr (StdVector CDouble) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_stdvectordouble"
+  c_delete_stdvectordouble' ::  Ptr (StdVector CDouble) -> IO ()
+
+instance CppObject (StdVector CDouble) where
+  fromPtr ptr = newForeignPtr c_delete_stdvectordouble ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_stdvectordouble' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_stdvectorint"
+  c_delete_stdvectorint :: FunPtr ( Ptr (StdVector CInt) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_stdvectorint"
+  c_delete_stdvectorint' ::  Ptr (StdVector CInt) -> IO ()
+
+instance CppObject (StdVector CInt) where
+  fromPtr ptr = newForeignPtr c_delete_stdvectorint ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_stdvectorint' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_stdvectorbool"
+  c_delete_stdvectorbool :: FunPtr ( Ptr (StdVector CBool) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_stdvectorbool"
+  c_delete_stdvectorbool' ::  Ptr (StdVector CBool) -> IO ()
+
+instance CppObject (StdVector CBool) where
+  fromPtr ptr = newForeignPtr c_delete_stdvectorbool ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_stdvectorbool' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_stream"
+  c_delete_stream :: FunPtr ( Ptr Stream -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_stream"
+  c_delete_stream' ::  Ptr Stream -> IO ()
+
+instance CppObject Stream where
+  fromPtr ptr = newForeignPtr c_delete_stream ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_stream' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_arrayrefscalar"
+  c_delete_arrayrefscalar :: FunPtr ( Ptr (ArrayRef Scalar) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_arrayrefscalar"
+  c_delete_arrayrefscalar' ::  Ptr (ArrayRef Scalar) -> IO ()
+
+instance CppObject (ArrayRef Scalar) where
+  fromPtr ptr = newForeignPtr c_delete_arrayrefscalar ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_arrayrefscalar' ptr
+  {-# INLINE deletePtr #-}
+
+foreign import ccall unsafe "hasktorch_finalizer.h &delete_vectorscalar"
+  c_delete_vectorscalar :: FunPtr ( Ptr (StdVector Scalar) -> IO ())
+
+foreign import ccall unsafe "hasktorch_finalizer.h delete_vectorscalar"
+  c_delete_vectorscalar' ::  Ptr (StdVector Scalar) -> IO ()
+
+instance CppObject (StdVector Scalar) where
+  fromPtr ptr = newForeignPtr c_delete_vectorscalar ptr
+  {-# INLINE fromPtr #-}
+  deletePtr ptr = c_delete_vectorscalar' ptr
+  {-# INLINE deletePtr #-}
diff --git a/src/Torch/Internal/Type.hs b/src/Torch/Internal/Type.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Type.hs
@@ -0,0 +1,138 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Type where
+
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import qualified Language.Haskell.TH.Lib as TH
+import Foreign.C.Types (CInt)
+import Data.Int
+
+type ScalarType = Int8
+type DeviceType = Int16
+type Backend = CInt
+type Layout = Int8
+type MemoryFormat = Int8
+type QScheme = Int8
+
+-- std::vector<a>
+data StdVector a
+
+-- std::array<a>
+data StdArray a
+
+-- std::tuple<a>
+data StdTuple a
+
+-- at::Tensor
+data Tensor
+
+-- std::vector<at::Tensor>
+type TensorList = StdVector Tensor
+
+data TensorIndex
+
+data Scalar
+data TensorOptions
+
+data IntArrayRef
+-- std::vector<int64>
+type IntArray = StdVector Int64
+
+data ArrayRef a
+
+data Storage
+
+data StdString
+data Generator
+data Device
+data Context
+
+data C10Ptr a
+data Quantizer
+-- c10::intrusive_ptr<Quantizer>
+type ConstQuantizerPtr = C10Ptr Quantizer
+
+data Dimname
+type DimnameList = StdVector Dimname
+
+data Symbol
+
+data IValue
+type IValueList = StdVector IValue
+
+data Stream
+
+data C10Dict a
+data C10List a
+data C10Optional a
+
+data IVNone
+data IVObject
+data IVTuple
+data IVFuture
+data IVConstantString
+data Capsule
+data Blob
+
+data Module
+data SharedPtr a
+data JitGraph
+data JitNode
+data JitValue
+
+data Optimizer
+
+typeTable :: Map.Map C.TypeSpecifier TH.TypeQ
+typeTable = Map.fromList [
+        (C.TypeName "std::array", [t|StdArray|])
+      , (C.TypeName "std::vector", [t|StdVector|])
+      , (C.TypeName "std::tuple", [t|StdTuple|])
+      , (C.TypeName "at::Scalar", [t|Scalar|])
+      , (C.TypeName "at::Tensor", [t|Tensor|])
+      , (C.TypeName "at::TensorOptions", [t|TensorOptions|])
+      , (C.TypeName "at::IntArrayRef", [t|IntArrayRef|])
+      , (C.TypeName "at::ScalarType", [t|ScalarType|])
+      , (C.TypeName "at::DeviceType", [t|DeviceType|])
+      , (C.TypeName "at::Storage", [t|Storage|])
+      , (C.TypeName "c10::Device", [t|Device|])
+      , (C.TypeName "at::Generator", [t|Generator|])
+      , (C.TypeName "std::string", [t|StdString|])
+      , (C.TypeName "at::Backend", [t|Backend|])
+      , (C.TypeName "at::Layout", [t|Layout|])
+      , (C.TypeName "at::MemoryFormat", [t|MemoryFormat|])
+      , (C.TypeName "at::Context", [t|Context|])
+      , (C.TypeName "at::QScheme", [t|QScheme|])
+      , (C.TypeName "at::Dimname", [t|Dimname|])
+      , (C.TypeName "at::Symbol", [t|Symbol|])
+      , (C.TypeName "Quantizer", [t|Quantizer|])
+      , (C.TypeName "at::IValue", [t|IValue|])
+      , (C.TypeName "c10::Stream", [t|Stream|])
+      , (C.TypeName "c10::intrusive_ptr", [t|C10Ptr|])
+      , (C.TypeName "c10::Dict", [t|C10Dict|])
+      , (C.TypeName "c10::List", [t|C10List|])
+      , (C.TypeName "c10::optional", [t|C10Optional|])
+      , (C.TypeName "at::ivalue::Tuple", [t|IVTuple|])
+      , (C.TypeName "at::ivalue::Future", [t|IVFuture|])
+      , (C.TypeName "at::ivalue::ConstantString", [t|IVConstantString|])
+      , (C.TypeName "at::ivalue::Object", [t|IVObject|])
+      , (C.TypeName "torch::jit::CustomClassHolder", [t|Capsule|])
+      , (C.TypeName "caffe2::Blob", [t|Blob|])
+      , (C.TypeName "torch::jit::script::Module", [t|Module|])
+      , (C.TypeName "std::shared_ptr", [t|SharedPtr|])
+      , (C.TypeName "torch::jit::Graph", [t|JitGraph|])
+      , (C.TypeName "torch::jit::Node", [t|JitNode|])
+      , (C.TypeName "torch::jit::Value", [t|JitValue|])
+      , (C.TypeName "at::indexing::TensorIndex", [t|TensorIndex|])
+      , (C.TypeName "torch::optim::Optimizer", [t|Optimizer|])
+      , (C.TypeName "ArrayRef", [t|ArrayRef|])
+      , (C.TypeName "at::ArrayRef", [t|ArrayRef|])
+    ]
+
diff --git a/src/Torch/Internal/Unmanaged/Autograd.hs b/src/Torch/Internal/Unmanaged/Autograd.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Autograd.hs
@@ -0,0 +1,81 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Autograd where
+
+import Foreign.Ptr
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import Foreign.C.Types (CBool)
+
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<torch/types.h>"
+C.include "<torch/csrc/autograd/variable.h>"
+C.include "<torch/csrc/autograd/engine.h>"
+C.include "<ATen/core/functional.h>"
+
+grad :: Ptr Tensor -> Ptr TensorList -> IO (Ptr TensorList)
+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 { torch::autograd::impl::gradient_edge(y) };
+    if (!roots[0].function) {
+      throw std::runtime_error("Differentiated tensor not require grad");
+    }
+
+    if (y.numel() != 1) {
+      throw std::runtime_error("Differentiated tensor has more than a single element");
+    }
+    torch::autograd::variable_list grads { torch::ones_like(y) };
+
+    torch::autograd::edge_list output_edges;
+    output_edges.reserve(inputs.size());
+    for (torch::autograd::Variable input : inputs) {
+      const auto output_nr = input.output_nr();
+      auto grad_fn = input.grad_fn();
+      if (!grad_fn) {
+        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");
+      }
+      if (!grad_fn) {
+        output_edges.emplace_back();
+      } else {
+        output_edges.emplace_back(grad_fn, output_nr);
+      }
+    }
+
+    auto & engine = torch::autograd::Engine::get_default_engine();
+    auto outputs = engine.execute(roots, grads,
+                                  /*keep_graph=*/true,
+                                  /*create_graph=*/false,
+                                  /*accumulate_grad=*/false, // https://github.com/pytorch/pytorch/pull/46855
+                                                             // https://github.com/pytorch/pytorch/issues/46373
+                                  output_edges);
+
+    return new std::vector<at::Tensor>(at::fmap<at::Tensor>(outputs));
+  }|]
+
+makeIndependent :: Ptr Tensor -> CBool -> IO (Ptr Tensor)
+makeIndependent tensor requires_grad = [C.throwBlock| at::Tensor* {
+    return new at::Tensor($(at::Tensor* tensor)->detach().set_requires_grad($(bool requires_grad)));
+  }|]
+
+dropVariable :: Ptr Tensor -> IO (Ptr Tensor)
+dropVariable t = [C.throwBlock| at::Tensor* {
+    auto ret = $(at::Tensor* t)->detach();
+    ret.unsafeGetTensorImpl()->set_autograd_meta(nullptr);
+    return new at::Tensor(ret);
+  }|]
diff --git a/src/Torch/Internal/Unmanaged/Native.hs b/src/Torch/Internal/Unmanaged/Native.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native.hs
@@ -0,0 +1,37 @@
+
+module Torch.Internal.Unmanaged.Native
+ ( module Torch.Internal.Unmanaged.Native.Native0
+ , module Torch.Internal.Unmanaged.Native.Native1
+ , module Torch.Internal.Unmanaged.Native.Native2
+ , module Torch.Internal.Unmanaged.Native.Native3
+ , module Torch.Internal.Unmanaged.Native.Native4
+ , module Torch.Internal.Unmanaged.Native.Native5
+ , module Torch.Internal.Unmanaged.Native.Native6
+ , module Torch.Internal.Unmanaged.Native.Native7
+ , module Torch.Internal.Unmanaged.Native.Native8
+ , module Torch.Internal.Unmanaged.Native.Native9
+ , module Torch.Internal.Unmanaged.Native.Native10
+ , module Torch.Internal.Unmanaged.Native.Native11
+ , module Torch.Internal.Unmanaged.Native.Native12
+ , module Torch.Internal.Unmanaged.Native.Native13
+ , module Torch.Internal.Unmanaged.Native.Native14
+ , module Torch.Internal.Unmanaged.Native.Native15
+ , module Torch.Internal.Unmanaged.Native.Extra
+ ) where
+import Torch.Internal.Unmanaged.Native.Native0
+import Torch.Internal.Unmanaged.Native.Native1
+import Torch.Internal.Unmanaged.Native.Native2
+import Torch.Internal.Unmanaged.Native.Native3
+import Torch.Internal.Unmanaged.Native.Native4
+import Torch.Internal.Unmanaged.Native.Native5
+import Torch.Internal.Unmanaged.Native.Native6
+import Torch.Internal.Unmanaged.Native.Native7
+import Torch.Internal.Unmanaged.Native.Native8
+import Torch.Internal.Unmanaged.Native.Native9
+import Torch.Internal.Unmanaged.Native.Native10
+import Torch.Internal.Unmanaged.Native.Native11
+import Torch.Internal.Unmanaged.Native.Native12
+import Torch.Internal.Unmanaged.Native.Native13
+import Torch.Internal.Unmanaged.Native.Native14
+import Torch.Internal.Unmanaged.Native.Native15
+import Torch.Internal.Unmanaged.Native.Extra
diff --git a/src/Torch/Internal/Unmanaged/Native/Extra.hs b/src/Torch/Internal/Unmanaged/Native/Extra.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Extra.hs
@@ -0,0 +1,58 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Extra where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<tuple>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+max_values_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+max_values_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* {
+    auto ta = std::get<0>(at::max(
+      *$(at::Tensor* _self)
+    , $(int64_t _dim)
+    , $(bool _keepdim)));
+    return new at::Tensor(ta);
+  }|]
+
+min_values_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+min_values_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* {
+    auto ta = std::get<0>(at::min(
+      *$(at::Tensor* _self)
+    , $(int64_t _dim)
+    , $(bool _keepdim)));
+    return new at::Tensor(ta);
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native0.hs b/src/Torch/Internal/Unmanaged/Native/Native0.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native0.hs
@@ -0,0 +1,3349 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native0 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+_cast_Byte_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cast_Byte_tb _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Byte(
+    *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_cast_Byte_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_cast_Byte_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Byte(
+    *$(at::Tensor* _self)));
+  }|]
+
+_cast_Char_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cast_Char_tb _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Char(
+    *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_cast_Char_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_cast_Char_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Char(
+    *$(at::Tensor* _self)));
+  }|]
+
+_cast_Double_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cast_Double_tb _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Double(
+    *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_cast_Double_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_cast_Double_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Double(
+    *$(at::Tensor* _self)));
+  }|]
+
+_cast_Float_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cast_Float_tb _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Float(
+    *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_cast_Float_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_cast_Float_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Float(
+    *$(at::Tensor* _self)));
+  }|]
+
+_cast_Int_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cast_Int_tb _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Int(
+    *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_cast_Int_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_cast_Int_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Int(
+    *$(at::Tensor* _self)));
+  }|]
+
+_cast_Long_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cast_Long_tb _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Long(
+    *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_cast_Long_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_cast_Long_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Long(
+    *$(at::Tensor* _self)));
+  }|]
+
+_cast_Short_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cast_Short_tb _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Short(
+    *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_cast_Short_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_cast_Short_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Short(
+    *$(at::Tensor* _self)));
+  }|]
+
+_cast_Half_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cast_Half_tb _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Half(
+    *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_cast_Half_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_cast_Half_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cast_Half(
+    *$(at::Tensor* _self)));
+  }|]
+
+_make_dual_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_make_dual_ttl _primal _tangent _level =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_dual(
+    *$(at::Tensor* _primal)
+  , *$(at::Tensor* _tangent)
+  , $(int64_t _level)));
+  }|]
+
+_unpack_dual_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_unpack_dual_tl _dual _level =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_unpack_dual(
+    *$(at::Tensor* _dual)
+  , $(int64_t _level)));
+  }|]
+
+_new_zeros_with_same_feature_meta_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_new_zeros_with_same_feature_meta_ttl _self _other _self_num_batch_dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_new_zeros_with_same_feature_meta(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(int64_t _self_num_batch_dims)));
+  }|]
+
+_new_zeros_with_same_feature_meta_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_new_zeros_with_same_feature_meta_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_new_zeros_with_same_feature_meta(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+_has_same_storage_numel_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+_has_same_storage_numel_tt _self _other =
+  [C.throwBlock| bool { return (at::_has_same_storage_numel(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+align_tensors_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+align_tensors_l _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::align_tensors(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+_assert_async_t
+  :: Ptr Tensor
+  -> IO (())
+_assert_async_t _self =
+  [C.throwBlock| void {  (at::_assert_async(
+    *$(at::Tensor* _self)));
+  }|]
+
+_assert_tensor_metadata_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> ScalarType
+  -> IO (())
+_assert_tensor_metadata_tlls _a _size _stride _dtype =
+  [C.throwBlock| void {  (at::_assert_tensor_metadata(
+    *$(at::Tensor* _a)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_assert_tensor_metadata_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (())
+_assert_tensor_metadata_tll _a _size _stride =
+  [C.throwBlock| void {  (at::_assert_tensor_metadata(
+    *$(at::Tensor* _a)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+_assert_tensor_metadata_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+_assert_tensor_metadata_tl _a _size =
+  [C.throwBlock| void {  (at::_assert_tensor_metadata(
+    *$(at::Tensor* _a)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_assert_tensor_metadata_t
+  :: Ptr Tensor
+  -> IO (())
+_assert_tensor_metadata_t _a =
+  [C.throwBlock| void {  (at::_assert_tensor_metadata(
+    *$(at::Tensor* _a)));
+  }|]
+
+_use_cudnn_ctc_loss_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (CBool)
+_use_cudnn_ctc_loss_ttlll _log_probs _targets _input_lengths _target_lengths _blank =
+  [C.throwBlock| bool { return (at::_use_cudnn_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)));
+  }|]
+
+_use_cudnn_ctc_loss_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (CBool)
+_use_cudnn_ctc_loss_ttttl _log_probs _targets _input_lengths _target_lengths _blank =
+  [C.throwBlock| bool { return (at::_use_cudnn_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)));
+  }|]
+
+_cudnn_ctc_loss_ttlllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_cudnn_ctc_loss_ttlllbb _log_probs _targets _input_lengths _target_lengths _blank _deterministic _zero_infinity =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_cudnn_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)
+  , $(bool _deterministic)
+  , $(bool _zero_infinity)));
+  }|]
+
+_cudnn_ctc_loss_ttttlbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_cudnn_ctc_loss_ttttlbb _log_probs _targets _input_lengths _target_lengths _blank _deterministic _zero_infinity =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_cudnn_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)
+  , $(bool _deterministic)
+  , $(bool _zero_infinity)));
+  }|]
+
+_use_cudnn_rnn_flatten_weight
+  :: IO (CBool)
+_use_cudnn_rnn_flatten_weight  =
+  [C.throwBlock| bool { return (at::_use_cudnn_rnn_flatten_weight(
+    ));
+  }|]
+
+_cudnn_rnn_flatten_weight_lllllllbb
+  :: Ptr TensorList
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_cudnn_rnn_flatten_weight_lllllllbb _weight_arr _weight_stride0 _input_size _mode _hidden_size _proj_size _num_layers _batch_first _bidirectional =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cudnn_rnn_flatten_weight(
+    *$(std::vector<at::Tensor>* _weight_arr)
+  , $(int64_t _weight_stride0)
+  , $(int64_t _input_size)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _proj_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(bool _bidirectional)));
+  }|]
+
+_cudnn_rnn_tlltttllllbdbblt
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_cudnn_rnn_tlltttllllbdbblt _input _weight _weight_stride0 _weight_buf _hx _cx _mode _hidden_size _proj_size _num_layers _batch_first _dropout _train _bidirectional _batch_sizes _dropout_state =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_cudnn_rnn(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _weight)
+  , $(int64_t _weight_stride0)
+  , *$(at::Tensor* _weight_buf)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _cx)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _proj_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , *$(at::Tensor* _dropout_state)));
+  }|]
+
+_cudnn_rnn_backward_tlltttttttllllbdbbltta
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,4))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)))
+_cudnn_rnn_backward_tlltttttttllllbdbbltta _input _weight _weight_stride0 _weight_buf _hx _cx _output _grad_output _grad_hy _grad_cy _mode _hidden_size _proj_size _num_layers _batch_first _dropout _train _bidirectional _batch_sizes _dropout_state _reserve _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>(at::_cudnn_rnn_backward(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _weight)
+  , $(int64_t _weight_stride0)
+  , *$(at::Tensor* _weight_buf)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _proj_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , *$(at::Tensor* _dropout_state)
+  , *$(at::Tensor* _reserve)
+  , *$(std::array<bool,4>* _output_mask)));
+  }|]
+
+_cudnn_init_dropout_state_dblo
+  :: CDouble
+  -> CBool
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_cudnn_init_dropout_state_dblo _dropout _train _dropout_seed _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cudnn_init_dropout_state(
+    $(double _dropout)
+  , $(bool _train)
+  , $(int64_t _dropout_seed)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_debug_has_internal_overlap_t
+  :: Ptr Tensor
+  -> IO (Int64)
+_debug_has_internal_overlap_t _self =
+  [C.throwBlock| int64_t { return (at::_debug_has_internal_overlap(
+    *$(at::Tensor* _self)));
+  }|]
+
+_fused_dropout_tdG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_dropout_tdG _self _p _generator =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_dropout(
+    *$(at::Tensor* _self)
+  , $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+_fused_dropout_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_dropout_td _self _p =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_dropout(
+    *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+_masked_scale_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+_masked_scale_ttd _self _mask _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_scale(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , $(double _scale)));
+  }|]
+
+native_dropout_tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+native_dropout_tdb _input _p _train =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::native_dropout(
+    *$(at::Tensor* _input)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+native_dropout_backward_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+native_dropout_backward_ttd _grad_output _mask _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_dropout_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _mask)
+  , $(double _scale)));
+  }|]
+
+_sobol_engine_draw_tltlls
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_sobol_engine_draw_tltlls _quasi _n _sobolstate _dimension _num_generated _dtype =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_sobol_engine_draw(
+    *$(at::Tensor* _quasi)
+  , $(int64_t _n)
+  , *$(at::Tensor* _sobolstate)
+  , $(int64_t _dimension)
+  , $(int64_t _num_generated)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sobol_engine_ff__tltll
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_sobol_engine_ff__tltll _self _n _sobolstate _dimension _num_generated =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sobol_engine_ff_(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , *$(at::Tensor* _sobolstate)
+  , $(int64_t _dimension)
+  , $(int64_t _num_generated)));
+  }|]
+
+_sobol_engine_scramble__ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_sobol_engine_scramble__ttl _self _ltm _dimension =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sobol_engine_scramble_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _ltm)
+  , $(int64_t _dimension)));
+  }|]
+
+_sobol_engine_initialize_state__tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_sobol_engine_initialize_state__tl _self _dimension =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sobol_engine_initialize_state_(
+    *$(at::Tensor* _self)
+  , $(int64_t _dimension)));
+  }|]
+
+_reshape_from_tensor_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_reshape_from_tensor_tt _self _shape =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_reshape_from_tensor(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _shape)));
+  }|]
+
+_shape_as_tensor_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_shape_as_tensor_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_shape_as_tensor(
+    *$(at::Tensor* _self)));
+  }|]
+
+dropout_tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+dropout_tdb _input _p _train =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dropout(
+    *$(at::Tensor* _input)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+dropout__tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+dropout__tdb _self _p _train =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dropout_(
+    *$(at::Tensor* _self)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+feature_dropout_tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+feature_dropout_tdb _input _p _train =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::feature_dropout(
+    *$(at::Tensor* _input)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+feature_dropout__tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+feature_dropout__tdb _self _p _train =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::feature_dropout_(
+    *$(at::Tensor* _self)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+alpha_dropout_tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+alpha_dropout_tdb _input _p _train =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::alpha_dropout(
+    *$(at::Tensor* _input)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+alpha_dropout__tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+alpha_dropout__tdb _self _p _train =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::alpha_dropout_(
+    *$(at::Tensor* _self)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+feature_alpha_dropout_tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+feature_alpha_dropout_tdb _input _p _train =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::feature_alpha_dropout(
+    *$(at::Tensor* _input)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+feature_alpha_dropout__tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+feature_alpha_dropout__tdb _self _p _train =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::feature_alpha_dropout_(
+    *$(at::Tensor* _self)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+abs_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+abs_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::abs(
+    *$(at::Tensor* _self)));
+  }|]
+
+abs__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+abs__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::abs_(
+    *$(at::Tensor* _self)));
+  }|]
+
+abs_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+abs_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::abs_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+absolute_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+absolute_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::absolute(
+    *$(at::Tensor* _self)));
+  }|]
+
+absolute_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+absolute_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::absolute_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+angle_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+angle_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::angle(
+    *$(at::Tensor* _self)));
+  }|]
+
+angle_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+angle_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::angle_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+view_as_real_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+view_as_real_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_as_real(
+    *$(at::Tensor* _self)));
+  }|]
+
+view_as_complex_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+view_as_complex_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_as_complex(
+    *$(at::Tensor* _self)));
+  }|]
+
+sgn_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sgn_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sgn(
+    *$(at::Tensor* _self)));
+  }|]
+
+sgn_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sgn_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sgn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+real_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+real_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::real(
+    *$(at::Tensor* _self)));
+  }|]
+
+imag_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+imag_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::imag(
+    *$(at::Tensor* _self)));
+  }|]
+
+_conj_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_conj_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_conj(
+    *$(at::Tensor* _self)));
+  }|]
+
+conj_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+conj_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conj(
+    *$(at::Tensor* _self)));
+  }|]
+
+_conj_physical_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_conj_physical_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_conj_physical(
+    *$(at::Tensor* _self)));
+  }|]
+
+conj_physical_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+conj_physical_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conj_physical(
+    *$(at::Tensor* _self)));
+  }|]
+
+conj_physical_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conj_physical_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conj_physical_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+conj_physical__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+conj_physical__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conj_physical_(
+    *$(at::Tensor* _self)));
+  }|]
+
+resolve_conj_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+resolve_conj_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resolve_conj(
+    *$(at::Tensor* _self)));
+  }|]
+
+resolve_neg_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+resolve_neg_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resolve_neg(
+    *$(at::Tensor* _self)));
+  }|]
+
+_neg_view_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_neg_view_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_neg_view(
+    *$(at::Tensor* _self)));
+  }|]
+
+acos_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+acos_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::acos(
+    *$(at::Tensor* _self)));
+  }|]
+
+acos__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+acos__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::acos_(
+    *$(at::Tensor* _self)));
+  }|]
+
+acos_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+acos_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::acos_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+arccos_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arccos_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arccos(
+    *$(at::Tensor* _self)));
+  }|]
+
+arccos__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arccos__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arccos_(
+    *$(at::Tensor* _self)));
+  }|]
+
+arccos_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+arccos_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arccos_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+avg_pool1d_tlllbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool1d_tlllbb _self _kernel_size _stride _padding _ceil_mode _count_include_pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)));
+  }|]
+
+avg_pool1d_tlllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool1d_tlllb _self _kernel_size _stride _padding _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)));
+  }|]
+
+avg_pool1d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool1d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+avg_pool1d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool1d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+avg_pool1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool1d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+adaptive_avg_pool1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+adaptive_avg_pool1d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_avg_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+adaptive_max_pool1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool1d_tl _self _output_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::adaptive_max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+add_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+add_tts _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::add(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+add_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+add_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::add(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+add_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+add_out_ttts _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::add_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+add_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+add_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::add_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+_add_relu_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu_tts _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_add_relu_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_add_relu_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+_add_relu__tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu__tts _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_add_relu__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_add_relu__tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+_add_relu_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu_out_ttts _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_add_relu_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_add_relu_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+_add_relu_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu_tss _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_add_relu_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+_add_relu__tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu__tss _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_add_relu__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu__ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+add_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+add_tss _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::add(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+add_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+add_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::add(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+addmv_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmv_tttss _self _mat _vec _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addmv_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmv_ttts _self _mat _vec _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addmv_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addmv_ttt _self _mat _vec =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)));
+  }|]
+
+addmv__tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmv__tttss _self _mat _vec _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addmv__ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmv__ttts _self _mat _vec _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addmv__ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addmv__ttt _self _mat _vec =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)));
+  }|]
+
+addmv_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmv_out_ttttss _out _self _mat _vec _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addmv_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmv_out_tttts _out _self _mat _vec _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addmv_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addmv_out_tttt _out _self _mat _vec =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)));
+  }|]
+
+addr_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addr_tttss _self _vec1 _vec2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addr(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec1)
+  , *$(at::Tensor* _vec2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addr_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addr_ttts _self _vec1 _vec2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addr(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec1)
+  , *$(at::Tensor* _vec2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addr_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addr_ttt _self _vec1 _vec2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addr(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec1)
+  , *$(at::Tensor* _vec2)));
+  }|]
+
+addr_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addr_out_ttttss _out _self _vec1 _vec2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec1)
+  , *$(at::Tensor* _vec2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addr_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addr_out_tttts _out _self _vec1 _vec2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec1)
+  , *$(at::Tensor* _vec2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addr_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addr_out_tttt _out _self _vec1 _vec2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec1)
+  , *$(at::Tensor* _vec2)));
+  }|]
+
+affine_grid_generator_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+affine_grid_generator_tlb _theta _size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::affine_grid_generator(
+    *$(at::Tensor* _theta)
+  , *$(std::vector<int64_t>* _size)
+  , $(bool _align_corners)));
+  }|]
+
+affine_grid_generator_backward_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+affine_grid_generator_backward_tlb _grad _size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::affine_grid_generator_backward(
+    *$(at::Tensor* _grad)
+  , *$(std::vector<int64_t>* _size)
+  , $(bool _align_corners)));
+  }|]
+
+_is_all_true_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_is_all_true_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_is_all_true(
+    *$(at::Tensor* _self)));
+  }|]
+
+_is_any_true_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_is_any_true_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_is_any_true(
+    *$(at::Tensor* _self)));
+  }|]
+
+_test_check_tensor_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_check_tensor_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_check_tensor(
+    *$(at::Tensor* _self)));
+  }|]
+
+all_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+all_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+all_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+all_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+all_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+all_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+all_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+all_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+all_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+all_tnb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+all_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+all_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+all_out_ttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+all_out_ttnb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+all_out_ttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+all_out_ttn _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+allclose_ttddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (CBool)
+allclose_ttddb _self _other _rtol _atol _equal_nan =
+  [C.throwBlock| bool { return (at::allclose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(double _rtol)
+  , $(double _atol)
+  , $(bool _equal_nan)));
+  }|]
+
+allclose_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (CBool)
+allclose_ttdd _self _other _rtol _atol =
+  [C.throwBlock| bool { return (at::allclose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(double _rtol)
+  , $(double _atol)));
+  }|]
+
+allclose_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (CBool)
+allclose_ttd _self _other _rtol =
+  [C.throwBlock| bool { return (at::allclose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(double _rtol)));
+  }|]
+
+allclose_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+allclose_tt _self _other =
+  [C.throwBlock| bool { return (at::allclose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+any_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+any_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+any_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+any_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+any_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+any_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+any_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+any_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+any_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+any_tnb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+any_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+any_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+any_out_ttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+any_out_ttnb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+any_out_ttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+any_out_ttn _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+arange_so
+  :: Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+arange_so _end _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange(
+    *$(at::Scalar* _end)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+arange_s
+  :: Ptr Scalar
+  -> IO (Ptr Tensor)
+arange_s _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange(
+    *$(at::Scalar* _end)));
+  }|]
+
+arange_sso
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+arange_sso _start _end _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+arange_ss
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+arange_ss _start _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)));
+  }|]
+
+arange_ssso
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+arange_ssso _start _end _step _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+arange_sss
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+arange_sss _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)));
+  }|]
+
+arange_out_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+arange_out_ts _out _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _end)));
+  }|]
+
+arange_out_tsss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+arange_out_tsss _out _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)));
+  }|]
+
+-- arange_out_tss
+--   :: Ptr Tensor
+--   -> Ptr Scalar
+--   -> Ptr Scalar
+--   -> IO (Ptr Tensor)
+-- arange_out_tss _out _start _end =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::arange_out(
+--     *$(at::Tensor* _out)
+--   , *$(at::Scalar* _start)
+--   , *$(at::Scalar* _end)));
+--   }|]
+
+_dim_arange_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_dim_arange_tl _like _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_dim_arange(
+    *$(at::Tensor* _like)
+  , $(int64_t _dim)));
+  }|]
+
+argmax_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+argmax_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+argmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+argmax_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+argmax_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+argmax_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmax(
+    *$(at::Tensor* _self)));
+  }|]
+
+argmax_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+argmax_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+argmax_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+argmax_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+argmax_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+argmax_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+argmin_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+argmin_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmin(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+argmin_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+argmin_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmin(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+argmin_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+argmin_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmin(
+    *$(at::Tensor* _self)));
+  }|]
+
+argmin_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+argmin_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+argmin_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+argmin_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+argmin_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+argmin_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argmin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+acosh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+acosh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::acosh(
+    *$(at::Tensor* _self)));
+  }|]
+
+acosh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+acosh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::acosh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+acosh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+acosh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::acosh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+arccosh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arccosh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arccosh(
+    *$(at::Tensor* _self)));
+  }|]
+
+arccosh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arccosh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arccosh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+arccosh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+arccosh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arccosh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+asinh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+asinh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::asinh(
+    *$(at::Tensor* _self)));
+  }|]
+
+asinh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+asinh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::asinh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+asinh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+asinh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::asinh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+arcsinh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arcsinh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arcsinh(
+    *$(at::Tensor* _self)));
+  }|]
+
+arcsinh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arcsinh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arcsinh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+arcsinh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+arcsinh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arcsinh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+atanh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+atanh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atanh(
+    *$(at::Tensor* _self)));
+  }|]
+
+atanh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+atanh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atanh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+atanh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+atanh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atanh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+arctanh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arctanh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arctanh(
+    *$(at::Tensor* _self)));
+  }|]
+
+arctanh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arctanh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arctanh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+arctanh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+arctanh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arctanh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+as_strided_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+as_strided_tlll _self _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+as_strided_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+as_strided_tll _self _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+as_strided__tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+as_strided__tlll _self _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+as_strided__tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+as_strided__tll _self _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+asin_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+asin_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::asin(
+    *$(at::Tensor* _self)));
+  }|]
+
+asin__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+asin__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::asin_(
+    *$(at::Tensor* _self)));
+  }|]
+
+asin_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+asin_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::asin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+arcsin_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arcsin_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arcsin(
+    *$(at::Tensor* _self)));
+  }|]
+
+arcsin__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arcsin__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arcsin_(
+    *$(at::Tensor* _self)));
+  }|]
+
+arcsin_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+arcsin_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arcsin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+atan_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+atan_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atan(
+    *$(at::Tensor* _self)));
+  }|]
+
+atan__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+atan__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atan_(
+    *$(at::Tensor* _self)));
+  }|]
+
+atan_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+atan_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atan_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+arctan_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arctan_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arctan(
+    *$(at::Tensor* _self)));
+  }|]
+
+arctan__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+arctan__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arctan_(
+    *$(at::Tensor* _self)));
+  }|]
+
+arctan_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+arctan_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arctan_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+atleast_1d_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+atleast_1d_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atleast_1d(
+    *$(at::Tensor* _self)));
+  }|]
+
+atleast_1d_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+atleast_1d_l _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::atleast_1d(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+atleast_2d_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+atleast_2d_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atleast_2d(
+    *$(at::Tensor* _self)));
+  }|]
+
+atleast_2d_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+atleast_2d_l _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::atleast_2d(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+atleast_3d_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+atleast_3d_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atleast_3d(
+    *$(at::Tensor* _self)));
+  }|]
+
+atleast_3d_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+atleast_3d_l _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::atleast_3d(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+baddbmm_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+baddbmm_tttss _self _batch1 _batch2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::baddbmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+baddbmm_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+baddbmm_ttts _self _batch1 _batch2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::baddbmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+baddbmm_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+baddbmm_ttt _self _batch1 _batch2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::baddbmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)));
+  }|]
+
+baddbmm_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+baddbmm_out_ttttss _out _self _batch1 _batch2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::baddbmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+baddbmm_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+baddbmm_out_tttts _out _self _batch1 _batch2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::baddbmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+baddbmm_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+baddbmm_out_tttt _out _self _batch1 _batch2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::baddbmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)));
+  }|]
+
+bartlett_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+bartlett_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bartlett_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+bartlett_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+bartlett_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bartlett_window(
+    $(int64_t _window_length)));
+  }|]
+
+bartlett_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+bartlett_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bartlett_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+bartlett_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+bartlett_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bartlett_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+batch_norm_tttttbddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+batch_norm_tttttbddb _input _weight _bias _running_mean _running_var _training _momentum _eps _cudnn_enabled =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::batch_norm(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _momentum)
+  , $(double _eps)
+  , $(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
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)))
+_batch_norm_impl_index_tttttbddb _input _weight _bias _running_mean _running_var _training _momentum _eps _cudnn_enabled =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>(at::_batch_norm_impl_index(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _momentum)
+  , $(double _eps)
+  , $(bool _cudnn_enabled)));
+  }|]
+
+_batch_norm_impl_index_backward_ltttttttbdat
+  :: Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> Ptr (StdArray '(CBool,3))
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_batch_norm_impl_index_backward_ltttttttbdat _impl_index _input _grad_output _weight _running_mean _running_var _save_mean _save_var_transform _train _eps _output_mask _reservedSpace =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_batch_norm_impl_index_backward(
+    $(int64_t _impl_index)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_var_transform)
+  , $(bool _train)
+  , $(double _eps)
+  , *$(std::array<bool,3>* _output_mask)
+  , *$(at::Tensor* _reservedSpace)));
+  }|]
+
+bernoulli_tG
+  :: Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+bernoulli_tG _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli(
+    *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+bernoulli_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+bernoulli_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli(
+    *$(at::Tensor* _self)));
+  }|]
+
+bernoulli_out_ttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+bernoulli_out_ttG _out _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+-- bernoulli_out_tt
+--   :: Ptr Tensor
+--   -> Ptr Tensor
+--   -> IO (Ptr Tensor)
+-- bernoulli_out_tt _out _self =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli_out(
+--     *$(at::Tensor* _out)
+--   , *$(at::Tensor* _self)));
+--   }|]
+
+bernoulli_tdG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+bernoulli_tdG _self _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli(
+    *$(at::Tensor* _self)
+  , $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+bernoulli_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+bernoulli_td _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli(
+    *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+bilinear_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bilinear_tttt _input1 _input2 _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bilinear(
+    *$(at::Tensor* _input1)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+bilinear_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bilinear_ttt _input1 _input2 _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bilinear(
+    *$(at::Tensor* _input1)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+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
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+binary_cross_entropy_with_logits_ttttl _self _target _weight _pos_weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_with_logits(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _pos_weight)
+  , $(int64_t _reduction)));
+  }|]
+
+binary_cross_entropy_with_logits_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_with_logits_tttt _self _target _weight _pos_weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_with_logits(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _pos_weight)));
+  }|]
+
+binary_cross_entropy_with_logits_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_with_logits_ttt _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_with_logits(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+binary_cross_entropy_with_logits_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_with_logits_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_with_logits(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+bincount_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+bincount_ttl _self _weights _minlength =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bincount(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weights)
+  , $(int64_t _minlength)));
+  }|]
+
+bincount_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bincount_tt _self _weights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bincount(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weights)));
+  }|]
+
+bincount_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+bincount_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bincount(
+    *$(at::Tensor* _self)));
+  }|]
+
+bitwise_not_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_not_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_not(
+    *$(at::Tensor* _self)));
+  }|]
+
+bitwise_not_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_not_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_not_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+copysign_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+copysign_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copysign_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+copysign_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+copysign_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copysign(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+copysign_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+copysign_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copysign(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+copysign_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+copysign_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copysign_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+logical_not_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+logical_not_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logical_not(
+    *$(at::Tensor* _self)));
+  }|]
+
+logical_not_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logical_not_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logical_not_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+logical_xor_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logical_xor_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logical_xor(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+logical_xor_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logical_xor_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logical_xor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(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
+  -> IO (Ptr Tensor)
+blackman_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::blackman_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+blackman_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+blackman_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::blackman_window(
+    $(int64_t _window_length)));
+  }|]
+
+blackman_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+blackman_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::blackman_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+blackman_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+blackman_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::blackman_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+bmm_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bmm_tt _self _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+bmm_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bmm_out_ttt _out _self _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+broadcast_tensors_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+broadcast_tensors_l _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::broadcast_tensors(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+broadcast_to_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+broadcast_to_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::broadcast_to(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_broadcast_to_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_broadcast_to_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_broadcast_to(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+cat_ll
+  :: Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+cat_ll _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cat(
+    *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+cat_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+cat_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cat(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+cat_out_tll
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+cat_out_tll _out _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cat_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+cat_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+cat_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cat_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+cat_ln
+  :: Ptr TensorList
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+cat_ln _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cat(
+    *$(std::vector<at::Tensor>* _tensors)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+cat_out_tln
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+cat_out_tln _out _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cat_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+concat_ll
+  :: Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+concat_ll _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concat(
+    *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+concat_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+concat_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concat(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+concat_out_tll
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+concat_out_tll _out _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concat_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+concat_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+concat_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concat_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+concat_ln
+  :: Ptr TensorList
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+concat_ln _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concat(
+    *$(std::vector<at::Tensor>* _tensors)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+concat_out_tln
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+concat_out_tln _out _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concat_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+concatenate_ll
+  :: Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+concatenate_ll _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concatenate(
+    *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+concatenate_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+concatenate_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concatenate(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+concatenate_out_tll
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+concatenate_out_tll _out _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concatenate_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+concatenate_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+concatenate_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concatenate_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+concatenate_ln
+  :: Ptr TensorList
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+concatenate_ln _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concatenate(
+    *$(std::vector<at::Tensor>* _tensors)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+concatenate_out_tln
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+concatenate_out_tln _out _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::concatenate_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , *$(at::Dimname* _dim)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native1.hs b/src/Torch/Internal/Unmanaged/Native/Native1.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native1.hs
@@ -0,0 +1,3566 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native1 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+block_diag_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+block_diag_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::block_diag(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+ceil_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+ceil_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ceil(
+    *$(at::Tensor* _self)));
+  }|]
+
+ceil__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+ceil__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ceil_(
+    *$(at::Tensor* _self)));
+  }|]
+
+ceil_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ceil_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ceil_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+chain_matmul_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+chain_matmul_l _matrices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::chain_matmul(
+    *$(std::vector<at::Tensor>* _matrices)));
+  }|]
+
+chain_matmul_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+chain_matmul_out_tl _out _matrices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::chain_matmul_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _matrices)));
+  }|]
+
+unsafe_chunk_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+unsafe_chunk_tll _self _chunks _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unsafe_chunk(
+    *$(at::Tensor* _self)
+  , $(int64_t _chunks)
+  , $(int64_t _dim)));
+  }|]
+
+unsafe_chunk_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+unsafe_chunk_tl _self _chunks =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unsafe_chunk(
+    *$(at::Tensor* _self)
+  , $(int64_t _chunks)));
+  }|]
+
+chunk_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+chunk_tll _self _chunks _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::chunk(
+    *$(at::Tensor* _self)
+  , $(int64_t _chunks)
+  , $(int64_t _dim)));
+  }|]
+
+chunk_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+chunk_tl _self _chunks =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::chunk(
+    *$(at::Tensor* _self)
+  , $(int64_t _chunks)));
+  }|]
+
+tensor_split_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_split_tll _self _sections _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::tensor_split(
+    *$(at::Tensor* _self)
+  , $(int64_t _sections)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_split_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_split_tl _self _sections =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::tensor_split(
+    *$(at::Tensor* _self)
+  , $(int64_t _sections)));
+  }|]
+
+tensor_split_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_split_ttl _self _tensor_indices_or_sections _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::tensor_split(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor_indices_or_sections)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_split_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr TensorList)
+tensor_split_tt _self _tensor_indices_or_sections =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::tensor_split(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor_indices_or_sections)));
+  }|]
+
+clamp_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_tss _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clamp_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_ts _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clamp_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp(
+    *$(at::Tensor* _self)));
+  }|]
+
+clamp_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_ttt _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clamp_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_tt _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+clamp__tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp__tss _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clamp__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp__ts _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clamp__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_(
+    *$(at::Tensor* _self)));
+  }|]
+
+clamp__ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp__ttt _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clamp__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp__tt _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+clamp_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_out_ttss _out _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clamp_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_out_tts _out _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clamp_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+clamp_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_out_tttt _out _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clamp_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_out_ttt _out _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+clamp_max_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_max_ts _self _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_max(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clamp_max_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_max_tt _self _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_max(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clamp_max__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_max__ts _self _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_max_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clamp_max__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_max__tt _self _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_max_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clamp_max_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_max_out_tts _out _self _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_max_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clamp_max_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_max_out_ttt _out _self _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_max_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clamp_min_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_min_ts _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_min(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clamp_min_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_min_tt _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_min(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+clamp_min__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_min__ts _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_min_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clamp_min__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_min__tt _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_min_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+clamp_min_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clamp_min_out_tts _out _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_min_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clamp_min_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clamp_min_out_ttt _out _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clamp_min_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+clip_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clip_tss _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clip_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clip_ts _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clip_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+clip_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip(
+    *$(at::Tensor* _self)));
+  }|]
+
+clip_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clip_ttt _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clip_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clip_tt _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+clip__tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clip__tss _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clip__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clip__ts _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clip__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+clip__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_(
+    *$(at::Tensor* _self)));
+  }|]
+
+clip__ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clip__ttt _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clip__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clip__tt _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+clip_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clip_out_ttss _out _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+clip_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+clip_out_tts _out _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min)));
+  }|]
+
+clip_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clip_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+clip_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clip_out_tttt _out _self _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+clip_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clip_out_ttt _out _self _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clip_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _min)));
+  }|]
+
+cudnn_is_acceptable_t
+  :: Ptr Tensor
+  -> IO (CBool)
+cudnn_is_acceptable_t _self =
+  [C.throwBlock| bool { return (at::cudnn_is_acceptable(
+    *$(at::Tensor* _self)));
+  }|]
+
+complex_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+complex_tt _real _imag =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::complex(
+    *$(at::Tensor* _real)
+  , *$(at::Tensor* _imag)));
+  }|]
+
+complex_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+complex_out_ttt _out _real _imag =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::complex_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _real)
+  , *$(at::Tensor* _imag)));
+  }|]
+
+polar_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+polar_tt _abs _angle =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::polar(
+    *$(at::Tensor* _abs)
+  , *$(at::Tensor* _angle)));
+  }|]
+
+polar_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+polar_out_ttt _out _abs _angle =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::polar_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _abs)
+  , *$(at::Tensor* _angle)));
+  }|]
+
+constant_pad_nd_tls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+constant_pad_nd_tls _self _pad _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::constant_pad_nd(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)
+  , *$(at::Scalar* _value)));
+  }|]
+
+constant_pad_nd_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+constant_pad_nd_tl _self _pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::constant_pad_nd(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)));
+  }|]
+
+convolution_tttlllbll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+convolution_tttlllbll _input _weight _bias _stride _padding _dilation _transposed _output_padding _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::convolution(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)));
+  }|]
+
+convolution_backward_tttllllblla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+convolution_backward_tttllllblla _grad_output _input _weight _bias_sizes _stride _padding _dilation _transposed _output_padding _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::convolution_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _bias_sizes)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+convolution_overrideable_tttlllbll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+convolution_overrideable_tttlllbll _input _weight _bias _stride _padding _dilation _transposed _output_padding _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::convolution_overrideable(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)));
+  }|]
+
+convolution_backward_overrideable_tttlllblla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+convolution_backward_overrideable_tttlllblla _grad_output _input _weight _stride _padding _dilation _transposed _output_padding _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::convolution_backward_overrideable(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+_convolution_tttlllbllbbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_convolution_tttlllbllbbbb _input _weight _bias _stride _padding _dilation _transposed _output_padding _groups _benchmark _deterministic _cudnn_enabled _allow_tf32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convolution(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)
+  , $(bool _cudnn_enabled)
+  , $(bool _allow_tf32)));
+  }|]
+
+_convolution_tttlllbllbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_convolution_tttlllbllbbb _input _weight _bias _stride _padding _dilation _transposed _output_padding _groups _benchmark _deterministic _cudnn_enabled =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convolution(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)
+  , $(bool _cudnn_enabled)));
+  }|]
+
+_convolution_mode_tttlsll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+_convolution_mode_tttlsll _input _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convolution_mode(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+_convolution_double_backward_ttttttlllblla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_convolution_double_backward_ttttttlllblla _ggI _ggW _ggb _gO _weight _self _stride _padding _dilation _transposed _output_padding _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_convolution_double_backward(
+    *$(at::Tensor* _ggI)
+  , *$(at::Tensor* _ggW)
+  , *$(at::Tensor* _ggb)
+  , *$(at::Tensor* _gO)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+conv1d_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv1d_tttllll _input _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+conv1d_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv1d_tttlll _input _weight _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv1d_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv1d_tttll _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+conv1d_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv1d_tttl _input _weight _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+conv1d_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv1d_ttt _input _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+conv1d_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv1d_tt _input _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+conv2d_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv2d_tttllll _input _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+conv2d_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv2d_tttlll _input _weight _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv2d_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv2d_tttll _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+conv2d_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv2d_tttl _input _weight _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+conv2d_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv2d_ttt _input _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+conv2d_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv2d_tt _input _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+conv3d_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv3d_tttllll _input _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+conv3d_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv3d_tttlll _input _weight _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv3d_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv3d_tttll _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+conv3d_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv3d_tttl _input _weight _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+conv3d_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv3d_ttt _input _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+conv3d_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv3d_tt _input _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+conv1d_tttlsll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv1d_tttlsll _input _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+conv1d_tttlsl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv1d_tttlsl _input _weight _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv1d_tttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+conv1d_tttls _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)));
+  }|]
+
+conv2d_tttlsll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv2d_tttlsll _input _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+conv2d_tttlsl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv2d_tttlsl _input _weight _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv2d_tttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+conv2d_tttls _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)));
+  }|]
+
+conv3d_tttlsll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv3d_tttlsll _input _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+conv3d_tttlsl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv3d_tttlsl _input _weight _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv3d_tttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+conv3d_tttls _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::string* _padding)));
+  }|]
+
+conv_tbc_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+conv_tbc_tttl _self _weight _bias _pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_tbc(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(int64_t _pad)));
+  }|]
+
+conv_tbc_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv_tbc_ttt _self _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_tbc(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+conv_tbc_backward_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+conv_tbc_backward_ttttl _self _input _weight _bias _pad =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::conv_tbc_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(int64_t _pad)));
+  }|]
+
+conv_transpose1d_tttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose1d_tttlllll _input _weight _bias _stride _padding _output_padding _groups _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv_transpose1d_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv_transpose1d_tttllll _input _weight _bias _stride _padding _output_padding _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)));
+  }|]
+
+conv_transpose1d_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose1d_tttlll _input _weight _bias _stride _padding _output_padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)));
+  }|]
+
+conv_transpose1d_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose1d_tttll _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+conv_transpose1d_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose1d_tttl _input _weight _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+conv_transpose1d_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv_transpose1d_ttt _input _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+conv_transpose1d_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv_transpose1d_tt _input _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose1d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+conv_transpose2d_tttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose2d_tttlllll _input _weight _bias _stride _padding _output_padding _groups _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv_transpose2d_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv_transpose2d_tttllll _input _weight _bias _stride _padding _output_padding _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)));
+  }|]
+
+conv_transpose2d_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose2d_tttlll _input _weight _bias _stride _padding _output_padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)));
+  }|]
+
+conv_transpose2d_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose2d_tttll _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+conv_transpose2d_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose2d_tttl _input _weight _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+conv_transpose2d_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv_transpose2d_ttt _input _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+conv_transpose2d_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv_transpose2d_tt _input _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+conv_transpose3d_tttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose3d_tttlllll _input _weight _bias _stride _padding _output_padding _groups _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv_transpose3d_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+conv_transpose3d_tttllll _input _weight _bias _stride _padding _output_padding _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)));
+  }|]
+
+conv_transpose3d_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose3d_tttlll _input _weight _bias _stride _padding _output_padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)));
+  }|]
+
+conv_transpose3d_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose3d_tttll _input _weight _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+conv_transpose3d_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_transpose3d_tttl _input _weight _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+conv_transpose3d_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv_transpose3d_ttt _input _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+conv_transpose3d_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv_transpose3d_tt _input _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_transpose3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+copy_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+copy_ttb _self _src _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(bool _non_blocking)));
+  }|]
+
+copy_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+copy_tt _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+_copy_from_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_copy_from_ttb _self _dst _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_copy_from(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _dst)
+  , $(bool _non_blocking)));
+  }|]
+
+_copy_from_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_copy_from_tt _self _dst =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_copy_from(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _dst)));
+  }|]
+
+_copy_from_and_resize_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_copy_from_and_resize_tt _self _dst =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_copy_from_and_resize(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _dst)));
+  }|]
+
+cos_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cos_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cos(
+    *$(at::Tensor* _self)));
+  }|]
+
+cos__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cos__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cos_(
+    *$(at::Tensor* _self)));
+  }|]
+
+cos_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cos_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cos_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+cosh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cosh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosh(
+    *$(at::Tensor* _self)));
+  }|]
+
+cosh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cosh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+cosh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cosh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+cosine_embedding_loss_tttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+cosine_embedding_loss_tttdl _input1 _input2 _target _margin _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosine_embedding_loss(
+    *$(at::Tensor* _input1)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _target)
+  , $(double _margin)
+  , $(int64_t _reduction)));
+  }|]
+
+cosine_embedding_loss_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+cosine_embedding_loss_tttd _input1 _input2 _target _margin =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosine_embedding_loss(
+    *$(at::Tensor* _input1)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _target)
+  , $(double _margin)));
+  }|]
+
+cosine_embedding_loss_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cosine_embedding_loss_ttt _input1 _input2 _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosine_embedding_loss(
+    *$(at::Tensor* _input1)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _target)));
+  }|]
+
+count_nonzero_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+count_nonzero_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::count_nonzero(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+count_nonzero_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+count_nonzero_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::count_nonzero(
+    *$(at::Tensor* _self)));
+  }|]
+
+cov_tltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cov_tltt _self _correction _fweights _aweights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cov(
+    *$(at::Tensor* _self)
+  , $(int64_t _correction)
+  , *$(at::Tensor* _fweights)
+  , *$(at::Tensor* _aweights)));
+  }|]
+
+cov_tlt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cov_tlt _self _correction _fweights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cov(
+    *$(at::Tensor* _self)
+  , $(int64_t _correction)
+  , *$(at::Tensor* _fweights)));
+  }|]
+
+cov_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cov_tl _self _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cov(
+    *$(at::Tensor* _self)
+  , $(int64_t _correction)));
+  }|]
+
+cov_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cov_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cov(
+    *$(at::Tensor* _self)));
+  }|]
+
+corrcoef_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+corrcoef_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::corrcoef(
+    *$(at::Tensor* _self)));
+  }|]
+
+cudnn_affine_grid_generator_tllll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+cudnn_affine_grid_generator_tllll _theta _N _C _H _W =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_affine_grid_generator(
+    *$(at::Tensor* _theta)
+  , $(int64_t _N)
+  , $(int64_t _C)
+  , $(int64_t _H)
+  , $(int64_t _W)));
+  }|]
+
+cudnn_affine_grid_generator_backward_tllll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+cudnn_affine_grid_generator_backward_tllll _grad _N _C _H _W =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_affine_grid_generator_backward(
+    *$(at::Tensor* _grad)
+  , $(int64_t _N)
+  , $(int64_t _C)
+  , $(int64_t _H)
+  , $(int64_t _W)));
+  }|]
+
+cudnn_batch_norm_tttttbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+cudnn_batch_norm_tttttbdd _input _weight _bias _running_mean _running_var _training _exponential_average_factor _epsilon =
+  [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::cudnn_batch_norm(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _exponential_average_factor)
+  , $(double _epsilon)));
+  }|]
+
+cudnn_batch_norm_backward_tttttttdt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+cudnn_batch_norm_backward_tttttttdt _input _grad_output _weight _running_mean _running_var _save_mean _save_var _epsilon _reserveSpace =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::cudnn_batch_norm_backward(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_var)
+  , $(double _epsilon)
+  , *$(at::Tensor* _reserveSpace)));
+  }|]
+
+cudnn_convolution_ttllllbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+cudnn_convolution_ttllllbbb _self _weight _padding _stride _dilation _groups _benchmark _deterministic _allow_tf32 =
+  [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)
+  , $(bool _allow_tf32)));
+  }|]
+
+cudnn_convolution_transpose_ttlllllbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+cudnn_convolution_transpose_ttlllllbbb _self _weight _padding _output_padding _stride _dilation _groups _benchmark _deterministic _allow_tf32 =
+  [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)
+  , $(bool _allow_tf32)));
+  }|]
+
+_mps_convolution_transpose_ttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+_mps_convolution_transpose_ttlllll _self _weight _padding _output_padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mps_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)));
+  }|]
+
+mps_convolution_transpose_backward_tttllllla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mps_convolution_transpose_backward_tttllllla _self _grad_output _weight _padding _output_padding _stride _dilation _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mps_convolution_transpose_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_output)
+  , *$(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)
+  , *$(std::array<bool,2>* _output_mask)));
+  }|]
+
+cudnn_convolution_relu_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+cudnn_convolution_relu_tttllll _self _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+cudnn_convolution_add_relu_tttstllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+cudnn_convolution_add_relu_tttstllll _self _weight _z _alpha _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_add_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _z)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+cudnn_grid_sampler_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cudnn_grid_sampler_tt _self _grid =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_grid_sampler(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _grid)));
+  }|]
+
+cudnn_grid_sampler_backward_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cudnn_grid_sampler_backward_ttt _self _grid _grad_output =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cudnn_grid_sampler_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _grid)
+  , *$(at::Tensor* _grad_output)));
+  }|]
+
+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)));
+  }|]
+
+cummaxmin_backward_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cummaxmin_backward_tttl _grad _input _indices _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cummaxmin_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _dim)));
+  }|]
+
+cumprod_tls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+cumprod_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+cumprod_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cumprod_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+cumprod_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(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+cumprod_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(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+cumprod_tns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+cumprod_tns _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+cumprod_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+cumprod_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+cumprod_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(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+cumprod_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(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+cumprod_backward_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cumprod_backward_ttlt _grad _input _dim _output =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumprod_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _input)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _output)));
+  }|]
+
+cumsum_tls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+cumsum_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+cumsum_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cumsum_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+cumsum_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(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+cumsum_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(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+cumsum_tns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+cumsum_tns _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+cumsum_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+cumsum_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumsum(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+cumsum_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(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+cumsum_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(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+cumulative_trapezoid_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cumulative_trapezoid_ttl _y _x _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumulative_trapezoid(
+    *$(at::Tensor* _y)
+  , *$(at::Tensor* _x)
+  , $(int64_t _dim)));
+  }|]
+
+cumulative_trapezoid_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cumulative_trapezoid_tt _y _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumulative_trapezoid(
+    *$(at::Tensor* _y)
+  , *$(at::Tensor* _x)));
+  }|]
+
+cumulative_trapezoid_tsl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr Tensor)
+cumulative_trapezoid_tsl _y _dx _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumulative_trapezoid(
+    *$(at::Tensor* _y)
+  , *$(at::Scalar* _dx)
+  , $(int64_t _dim)));
+  }|]
+
+cumulative_trapezoid_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+cumulative_trapezoid_ts _y _dx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumulative_trapezoid(
+    *$(at::Tensor* _y)
+  , *$(at::Scalar* _dx)));
+  }|]
+
+cumulative_trapezoid_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cumulative_trapezoid_t _y =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cumulative_trapezoid(
+    *$(at::Tensor* _y)));
+  }|]
+
+ctc_loss_ttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+ctc_loss_ttllllb _log_probs _targets _input_lengths _target_lengths _blank _reduction _zero_infinity =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)
+  , $(int64_t _reduction)
+  , $(bool _zero_infinity)));
+  }|]
+
+ctc_loss_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+ctc_loss_ttllll _log_probs _targets _input_lengths _target_lengths _blank _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)
+  , $(int64_t _reduction)));
+  }|]
+
+ctc_loss_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+ctc_loss_ttlll _log_probs _targets _input_lengths _target_lengths _blank =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)));
+  }|]
+
+ctc_loss_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+ctc_loss_ttll _log_probs _targets _input_lengths _target_lengths =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)));
+  }|]
+
+ctc_loss_ttttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+ctc_loss_ttttllb _log_probs _targets _input_lengths _target_lengths _blank _reduction _zero_infinity =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)
+  , $(int64_t _reduction)
+  , $(bool _zero_infinity)));
+  }|]
+
+ctc_loss_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+ctc_loss_ttttll _log_probs _targets _input_lengths _target_lengths _blank _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)
+  , $(int64_t _reduction)));
+  }|]
+
+ctc_loss_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+ctc_loss_ttttl _log_probs _targets _input_lengths _target_lengths _blank =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)));
+  }|]
+
+ctc_loss_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ctc_loss_tttt _log_probs _targets _input_lengths _target_lengths =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)));
+  }|]
+
+_ctc_loss_ttlllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttlllb _log_probs _targets _input_lengths _target_lengths _blank _zero_infinity =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)
+  , $(bool _zero_infinity)));
+  }|]
+
+_ctc_loss_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttlll _log_probs _targets _input_lengths _target_lengths _blank =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)));
+  }|]
+
+_ctc_loss_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttll _log_probs _targets _input_lengths _target_lengths =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)));
+  }|]
+
+_ctc_loss_ttttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttttlb _log_probs _targets _input_lengths _target_lengths _blank _zero_infinity =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)
+  , $(bool _zero_infinity)));
+  }|]
+
+_ctc_loss_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_ttttl _log_probs _targets _input_lengths _target_lengths _blank =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)));
+  }|]
+
+_ctc_loss_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_tttt _log_probs _targets _input_lengths _target_lengths =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss(
+    *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)));
+  }|]
+
+_ctc_loss_backward_tttllttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_ctc_loss_backward_tttllttlb _grad _log_probs _targets _input_lengths _target_lengths _neg_log_likelihood _log_alpha _blank _zero_infinity =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_ctc_loss_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , *$(at::Tensor* _neg_log_likelihood)
+  , *$(at::Tensor* _log_alpha)
+  , $(int64_t _blank)
+  , $(bool _zero_infinity)));
+  }|]
+
+_ctc_loss_backward_tttllttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_ctc_loss_backward_tttllttl _grad _log_probs _targets _input_lengths _target_lengths _neg_log_likelihood _log_alpha _blank =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_ctc_loss_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , *$(at::Tensor* _neg_log_likelihood)
+  , *$(at::Tensor* _log_alpha)
+  , $(int64_t _blank)));
+  }|]
+
+_ctc_loss_backward_tttttttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_ctc_loss_backward_tttttttlb _grad _log_probs _targets _input_lengths _target_lengths _neg_log_likelihood _log_alpha _blank _zero_infinity =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_ctc_loss_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , *$(at::Tensor* _neg_log_likelihood)
+  , *$(at::Tensor* _log_alpha)
+  , $(int64_t _blank)
+  , $(bool _zero_infinity)));
+  }|]
+
+_ctc_loss_backward_tttttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_ctc_loss_backward_tttttttl _grad _log_probs _targets _input_lengths _target_lengths _neg_log_likelihood _log_alpha _blank =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_ctc_loss_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , *$(at::Tensor* _neg_log_likelihood)
+  , *$(at::Tensor* _log_alpha)
+  , $(int64_t _blank)));
+  }|]
+
+diag_embed_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diag_embed_tlll _self _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_embed(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+diag_embed_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diag_embed_tll _self _offset _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_embed(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)));
+  }|]
+
+diag_embed_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diag_embed_tl _self _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_embed(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)));
+  }|]
+
+diag_embed_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+diag_embed_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_embed(
+    *$(at::Tensor* _self)));
+  }|]
+
+diagflat_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diagflat_tl _self _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagflat(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)));
+  }|]
+
+diagflat_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+diagflat_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagflat(
+    *$(at::Tensor* _self)));
+  }|]
+
+diagonal_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_tlll _self _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+diagonal_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_tll _self _offset _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)));
+  }|]
+
+diagonal_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_tl _self _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)));
+  }|]
+
+diagonal_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+diagonal_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_diagonal_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_diagonal_tlll _A _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_diagonal(
+    *$(at::Tensor* _A)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+linalg_diagonal_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_diagonal_tll _A _offset _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_diagonal(
+    *$(at::Tensor* _A)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)));
+  }|]
+
+linalg_diagonal_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_diagonal_tl _A _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_diagonal(
+    *$(at::Tensor* _A)
+  , $(int64_t _offset)));
+  }|]
+
+linalg_diagonal_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_diagonal_t _A =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_diagonal(
+    *$(at::Tensor* _A)));
+  }|]
+
+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)));
+  }|]
+
+diagonal_backward_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_backward_tllll _grad_output _input_sizes _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _input_sizes)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+diff_tlltt
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diff_tlltt _self _n _dim _prepend _append =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _prepend)
+  , *$(at::Tensor* _append)));
+  }|]
+
+diff_tllt
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diff_tllt _self _n _dim _prepend =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _prepend)));
+  }|]
+
+diff_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diff_tll _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+diff_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diff_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+diff_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+diff_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff(
+    *$(at::Tensor* _self)));
+  }|]
+
+diff_out_ttlltt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diff_out_ttlltt _out _self _n _dim _prepend _append =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _prepend)
+  , *$(at::Tensor* _append)));
+  }|]
+
+diff_out_ttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diff_out_ttllt _out _self _n _dim _prepend =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _prepend)));
+  }|]
+
+diff_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diff_out_ttll _out _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+diff_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diff_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+diff_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diff_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diff_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+gradient_tsll
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+gradient_tsll _self _spacing _dim _edge_order =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::gradient(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _spacing)
+  , $(int64_t _dim)
+  , $(int64_t _edge_order)));
+  }|]
+
+gradient_tsl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr TensorList)
+gradient_tsl _self _spacing _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::gradient(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _spacing)
+  , $(int64_t _dim)));
+  }|]
+
+gradient_t
+  :: Ptr Tensor
+  -> IO (Ptr TensorList)
+gradient_t _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::gradient(
+    *$(at::Tensor* _self)));
+  }|]
+
+gradient_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr TensorList)
+gradient_tll _self _dim _edge_order =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::gradient(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _edge_order)));
+  }|]
+
+gradient_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr TensorList)
+gradient_tl _self _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::gradient(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+gradient_tA
+  :: Ptr Tensor
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+gradient_tA _self _spacing =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::gradient(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Scalar>* _spacing)));
+  }|]
+
+div_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+div_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::div(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+div_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+div_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::div_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+div_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+div_tts _self _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::div(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+div_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+div_out_ttts _out _self _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::div_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+div_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+div_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::div(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+div_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+div_tss _self _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::div(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+divide_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+divide_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::divide(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+divide_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+divide_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::divide_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+divide_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+divide_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::divide(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+divide_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+divide_tts _self _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::divide(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+divide_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+divide_out_ttts _out _self _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::divide_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+divide_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+divide_tss _self _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::divide(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+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)));
+  }|]
+
+dot_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+dot_tt _self _tensor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dot(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor)));
+  }|]
+
+dot_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+dot_out_ttt _out _self _tensor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dot_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor)));
+  }|]
+
+vdot_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+vdot_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::vdot(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+vdot_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+vdot_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::vdot_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+einsum_sll
+  :: Ptr StdString
+  -> Ptr TensorList
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+einsum_sll _equation _tensors _path =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::einsum(
+    *$(std::string* _equation)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , *$(std::vector<int64_t>* _path)));
+  }|]
+
+einsum_sl
+  :: Ptr StdString
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+einsum_sl _equation _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::einsum(
+    *$(std::string* _equation)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+embedding_ttlbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+embedding_ttlbb _weight _indices _padding_idx _scale_grad_by_freq _sparse =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _padding_idx)
+  , $(bool _scale_grad_by_freq)
+  , $(bool _sparse)));
+  }|]
+
+embedding_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+embedding_ttlb _weight _indices _padding_idx _scale_grad_by_freq =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _padding_idx)
+  , $(bool _scale_grad_by_freq)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native10.hs b/src/Torch/Internal/Unmanaged/Native/Native10.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native10.hs
@@ -0,0 +1,3882 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native10 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+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_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_bicubic2d_aa_out_ttlbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_out_ttlbdd _out _self _output_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_bicubic2d_aa_out_ttlbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_out_ttlbd _out _self _output_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+_upsample_bicubic2d_aa_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_out_ttlb _out _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+_upsample_bicubic2d_aa_tlbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_tlbdd _self _output_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+-- _upsample_bicubic2d_aa_tlbd
+--   :: Ptr Tensor
+--   -> Ptr IntArray
+--   -> CBool
+--   -> CDouble
+--   -> IO (Ptr Tensor)
+-- _upsample_bicubic2d_aa_tlbd _self _output_size _align_corners _scales_h =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa(
+--     *$(at::Tensor* _self)
+--   , *$(std::vector<int64_t>* _output_size)
+--   , $(bool _align_corners)
+--   , $(double _scales_h)));
+--   }|]
+
+_upsample_bicubic2d_aa_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_tlb _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+_upsample_bicubic2d_aa_backward_out_ttllbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_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_aa_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_aa_backward_out_ttllbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_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_aa_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_aa_backward_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa_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_aa_backward_tllbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_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_aa_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_aa_backward_tllbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_backward_tllbd _grad_output _output_size _input_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa_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_aa_backward_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_backward_tllb _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa_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_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_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_nearest_exact1d_out_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact1d_out_ttld _out _self _output_size _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales)));
+  }|]
+
+_upsample_nearest_exact1d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact1d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+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_nearest_exact1d_tld
+--   :: Ptr Tensor
+--   -> Ptr IntArray
+--   -> CDouble
+--   -> IO (Ptr Tensor)
+-- _upsample_nearest_exact1d_tld _self _output_size _scales =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d(
+--     *$(at::Tensor* _self)
+--   , *$(std::vector<int64_t>* _output_size)
+--   , $(double _scales)));
+--   }|]
+
+_upsample_nearest_exact1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact1d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d(
+    *$(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_nearest_exact1d_backward_out_ttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact1d_backward_out_ttlld _grad_input _grad_output _output_size _input_size _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d_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_nearest_exact1d_backward_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact1d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d_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_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_nearest_exact1d_backward_tlld
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact1d_backward_tlld _grad_output _output_size _input_size _scales =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales)));
+  }|]
+
+_upsample_nearest_exact1d_backward_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact1d_backward_tll _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d_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_nearest_exact2d_out_ttldd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_out_ttldd _out _self _output_size _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_nearest_exact2d_out_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_out_ttld _out _self _output_size _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_h)));
+  }|]
+
+_upsample_nearest_exact2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d_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_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> 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_nearest_exact2d_tldd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_tldd _self _output_size _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+-- _upsample_nearest_exact2d_tld
+--   :: Ptr Tensor
+--   -> Ptr IntArray
+--   -> CDouble
+--   -> IO (Ptr Tensor)
+-- _upsample_nearest_exact2d_tld _self _output_size _scales_h =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d(
+--     *$(at::Tensor* _self)
+--   , *$(std::vector<int64_t>* _output_size)
+--   , $(double _scales_h)));
+--   }|]
+
+_upsample_nearest_exact2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+upsample_nearest2d_backward_out_ttlldd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_nearest2d_backward_out_ttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_h)));
+  }|]
+
+upsample_nearest2d_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(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+_upsample_nearest_exact2d_backward_out_ttlldd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_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_nearest_exact2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_nearest_exact2d_backward_out_ttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_backward_out_ttlld _grad_input _grad_output _output_size _input_size _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_h)));
+  }|]
+
+_upsample_nearest_exact2d_backward_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d_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_tlldd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_nearest2d_backward_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> 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(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+_upsample_nearest_exact2d_backward_tlldd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_backward_tlldd _grad_output _output_size _input_size _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_nearest_exact2d_backward_tlld
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_backward_tlld _grad_output _output_size _input_size _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_h)));
+  }|]
+
+_upsample_nearest_exact2d_backward_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_backward_tll _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+upsample_nearest3d_out_ttlddd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_nearest3d_out_ttldd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+upsample_nearest3d_out_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_d)));
+  }|]
+
+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_nearest_exact3d_out_ttlddd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_out_ttlddd _out _self _output_size _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_nearest_exact3d_out_ttldd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_out_ttldd _out _self _output_size _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+_upsample_nearest_exact3d_out_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_out_ttld _out _self _output_size _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_d)));
+  }|]
+
+_upsample_nearest_exact3d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+upsample_nearest3d_tlddd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_nearest3d_tldd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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_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_nearest_exact3d_tlddd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_tlddd _self _output_size _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_nearest_exact3d_tldd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_tldd _self _output_size _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+-- _upsample_nearest_exact3d_tld
+--   :: Ptr Tensor
+--   -> Ptr IntArray
+--   -> CDouble
+--   -> IO (Ptr Tensor)
+-- _upsample_nearest_exact3d_tld _self _output_size _scales_d =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d(
+--     *$(at::Tensor* _self)
+--   , *$(std::vector<int64_t>* _output_size)
+--   , $(double _scales_d)));
+--   }|]
+
+_upsample_nearest_exact3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+upsample_nearest3d_backward_out_ttllddd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_nearest3d_backward_out_ttlldd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+upsample_nearest3d_backward_out_ttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+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_nearest3d_backward_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> 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)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+_upsample_nearest_exact3d_backward_out_ttllddd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_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_nearest_exact3d_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)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_nearest_exact3d_backward_out_ttlldd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_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_nearest_exact3d_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)
+  , $(double _scales_h)));
+  }|]
+
+_upsample_nearest_exact3d_backward_out_ttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_backward_out_ttlld _grad_input _grad_output _output_size _input_size _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_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_nearest_exact3d_backward_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_backward_out_ttll _grad_input _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+upsample_nearest3d_backward_tllddd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+upsample_nearest3d_backward_tlldd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+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_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+upsample_nearest3d_backward_tll _grad_output _output_size _input_size =
+  [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)));
+  }|]
+
+_upsample_nearest_exact3d_backward_tllddd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_backward_tllddd _grad_output _output_size _input_size _scales_d _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_nearest_exact3d_backward_tlldd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_backward_tlldd _grad_output _output_size _input_size _scales_d _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)
+  , $(double _scales_h)));
+  }|]
+
+_upsample_nearest_exact3d_backward_tlld
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_backward_tlld _grad_output _output_size _input_size _scales_d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)
+  , $(double _scales_d)));
+  }|]
+
+_upsample_nearest_exact3d_backward_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_backward_tll _grad_output _output_size _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+sigmoid_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sigmoid_backward_out_ttt _grad_input _grad_output _output =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sigmoid_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)));
+  }|]
+
+sigmoid_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sigmoid_backward_tt _grad_output _output =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sigmoid_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)));
+  }|]
+
+logit_backward_out_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+logit_backward_out_tttd _grad_input _grad_output _self _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , $(double _eps)));
+  }|]
+
+logit_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logit_backward_out_ttt _grad_input _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+logit_backward_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+logit_backward_ttd _grad_output _self _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , $(double _eps)));
+  }|]
+
+logit_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logit_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+tanh_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tanh_backward_out_ttt _grad_input _grad_output _output =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tanh_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)));
+  }|]
+
+tanh_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tanh_backward_tt _grad_output _output =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tanh_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)));
+  }|]
+
+slow_conv_transpose2d_out_tttltllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_out_tttltllll _out _self _weight _kernel_size _bias _stride _padding _output_padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_transpose2d_out_tttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_out_tttltlll _out _self _weight _kernel_size _bias _stride _padding _output_padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)));
+  }|]
+
+slow_conv_transpose2d_out_tttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_out_tttltll _out _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_transpose2d_out_tttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_out_tttltl _out _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv_transpose2d_out_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_out_tttlt _out _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv_transpose2d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_out_tttl _out _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+slow_conv_transpose2d_ttltllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_ttltllll _self _weight _kernel_size _bias _stride _padding _output_padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_transpose2d_ttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_ttltlll _self _weight _kernel_size _bias _stride _padding _output_padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)));
+  }|]
+
+slow_conv_transpose2d_ttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_ttltll _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_transpose2d_ttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_ttltl _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv_transpose2d_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_ttlt _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv_transpose2d_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose2d_ttl _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+slow_conv_transpose3d_out_tttltllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_out_tttltllll _out _self _weight _kernel_size _bias _stride _padding _output_padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_transpose3d_out_tttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_out_tttltlll _out _self _weight _kernel_size _bias _stride _padding _output_padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)));
+  }|]
+
+slow_conv_transpose3d_out_tttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_out_tttltll _out _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_transpose3d_out_tttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_out_tttltl _out _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv_transpose3d_out_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_out_tttlt _out _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv_transpose3d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_out_tttl _out _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+slow_conv_transpose3d_ttltllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_ttltllll _self _weight _kernel_size _bias _stride _padding _output_padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_transpose3d_ttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_ttltlll _self _weight _kernel_size _bias _stride _padding _output_padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _output_padding)));
+  }|]
+
+slow_conv_transpose3d_ttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_ttltll _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_transpose3d_ttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_ttltl _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv_transpose3d_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_ttlt _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv_transpose3d_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_transpose3d_ttl _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_transpose3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+thnn_conv2d_out_tttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+thnn_conv2d_out_tttltll _out _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::thnn_conv2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+thnn_conv2d_out_tttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+thnn_conv2d_out_tttltl _out _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::thnn_conv2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+thnn_conv2d_out_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+thnn_conv2d_out_tttlt _out _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::thnn_conv2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+thnn_conv2d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+thnn_conv2d_out_tttl _out _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::thnn_conv2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+thnn_conv2d_ttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+thnn_conv2d_ttltll _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::thnn_conv2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+thnn_conv2d_ttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+thnn_conv2d_ttltl _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::thnn_conv2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+thnn_conv2d_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+thnn_conv2d_ttlt _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::thnn_conv2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+thnn_conv2d_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+thnn_conv2d_ttl _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::thnn_conv2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+_slow_conv2d_forward_out_tttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_slow_conv2d_forward_out_tttltll _output _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_slow_conv2d_forward_out(
+    *$(at::Tensor* _output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+_slow_conv2d_forward_ttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_slow_conv2d_forward_ttltll _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_slow_conv2d_forward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+_slow_conv2d_backward_out_ttttttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_slow_conv2d_backward_out_ttttttlll _grad_input _grad_weight _grad_bias _grad_output _self _weight _kernel_size _stride _padding =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_slow_conv2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_weight)
+  , *$(at::Tensor* _grad_bias)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+_slow_conv2d_backward_tttllla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_slow_conv2d_backward_tttllla _grad_output _self _weight _kernel_size _stride _padding _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_slow_conv2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+_conv_depthwise2d_out_tttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_conv_depthwise2d_out_tttltlll _out _self _weight _kernel_size _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_conv_depthwise2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+_conv_depthwise2d_ttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_conv_depthwise2d_ttltlll _self _weight _kernel_size _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_conv_depthwise2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+conv_depthwise3d_ttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_depthwise3d_ttltlll _self _weight _kernel_size _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_depthwise3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv3d_out_tttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv3d_out_tttltll _out _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv3d_out_tttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv3d_out_tttltl _out _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv3d_out_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv3d_out_tttlt _out _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv3d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv3d_out_tttl _out _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+slow_conv3d_ttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv3d_ttltll _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv3d_ttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv3d_ttltl _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv3d_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv3d_ttlt _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv3d_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv3d_ttl _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+slow_conv3d_forward_out_tttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv3d_forward_out_tttltll _output _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d_forward_out(
+    *$(at::Tensor* _output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv3d_forward_ttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv3d_forward_ttltll _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv3d_forward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_dilated2d_ttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_ttltlll _self _weight _kernel_size _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_dilated2d_ttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_ttltll _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_dilated2d_ttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_ttltl _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv_dilated2d_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_ttlt _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv_dilated2d_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_ttl _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+slow_conv_dilated3d_ttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_ttltlll _self _weight _kernel_size _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_dilated3d_ttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_ttltll _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_dilated3d_ttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_ttltl _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv_dilated3d_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_ttlt _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv_dilated3d_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_ttl _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+col2im_out_ttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+col2im_out_ttlllll _out _self _output_size _kernel_size _dilation _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::col2im_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _dilation)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+col2im_tlllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+col2im_tlllll _self _output_size _kernel_size _dilation _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::col2im(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _dilation)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+column_stack_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+column_stack_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::column_stack(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+column_stack_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+column_stack_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::column_stack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+im2col_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+im2col_out_ttllll _out _self _kernel_size _dilation _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::im2col_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _dilation)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+im2col_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+im2col_tllll _self _kernel_size _dilation _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::im2col(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _dilation)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+isfinite_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+isfinite_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isfinite(
+    *$(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)));
+  }|]
+
+isposinf_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+isposinf_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isposinf(
+    *$(at::Tensor* _self)));
+  }|]
+
+isposinf_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isposinf_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isposinf_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+isneginf_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+isneginf_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isneginf(
+    *$(at::Tensor* _self)));
+  }|]
+
+isneginf_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isneginf_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isneginf_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_add_batch_dim_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_add_batch_dim_tll _self _batch_dim _level =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_batch_dim(
+    *$(at::Tensor* _self)
+  , $(int64_t _batch_dim)
+  , $(int64_t _level)));
+  }|]
+
+_remove_batch_dim_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_remove_batch_dim_tlll _self _level _batch_size _out_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_remove_batch_dim(
+    *$(at::Tensor* _self)
+  , $(int64_t _level)
+  , $(int64_t _batch_size)
+  , $(int64_t _out_dim)));
+  }|]
+
+special_entr_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_entr_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_entr(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_entr_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_entr_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_entr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_ndtri_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_ndtri_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_ndtri(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_ndtri_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_ndtri_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_ndtri_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_log_ndtr_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_log_ndtr_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_log_ndtr(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_log_ndtr_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_log_ndtr_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_log_ndtr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_expm1_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_expm1_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_expm1(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_expm1_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_expm1_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_expm1_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_exp2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_exp2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_exp2(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_exp2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_exp2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_exp2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_psi_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_psi_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_psi(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_psi_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_psi_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_psi_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_digamma_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_digamma_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_digamma(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_digamma_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_digamma_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_digamma_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_gammaln_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_gammaln_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_gammaln(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_gammaln_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_gammaln_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_gammaln_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_erf_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_erf_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_erf(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_erf_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_erf_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_erf_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_erfc_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_erfc_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_erfc(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_erfc_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_erfc_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_erfc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_erfcx_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_erfcx_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_erfcx(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_erfcx_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_erfcx_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_erfcx_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_erfinv_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_erfinv_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_erfinv(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_erfinv_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_erfinv_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_erfinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_ndtr_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_ndtr_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_ndtr(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_ndtr_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_ndtr_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_ndtr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_xlog1py_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_xlog1py_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlog1py(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_xlog1py_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_xlog1py_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlog1py(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_xlog1py_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_xlog1py_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlog1py(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+special_xlog1py_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_xlog1py_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlog1py_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_xlog1py_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_xlog1py_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlog1py_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_xlog1py_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_xlog1py_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlog1py_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+special_xlogy_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_xlogy_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlogy(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_xlogy_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_xlogy_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlogy(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_xlogy_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_xlogy_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlogy(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+special_xlogy_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_xlogy_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlogy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_xlogy_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_xlogy_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlogy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_xlogy_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_xlogy_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_xlogy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+special_zeta_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_zeta_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_zeta(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_zeta_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_zeta_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_zeta(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_zeta_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_zeta_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_zeta(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+special_zeta_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_zeta_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_zeta_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_zeta_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_zeta_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_zeta_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_zeta_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_zeta_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_zeta_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+special_i0_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_i0_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_i0(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_i0_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_i0_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_i0_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_i0e_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_i0e_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_i0e(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_i0e_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_i0e_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_i0e_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_i1_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_i1_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_i1(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_i1_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_i1_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_i1_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_i1e_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_i1e_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_i1e(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_i1e_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_i1e_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_i1e_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_logit_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+special_logit_td _self _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_logit(
+    *$(at::Tensor* _self)
+  , $(double _eps)));
+  }|]
+
+special_logit_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_logit_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_logit(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_logit_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+special_logit_out_ttd _out _self _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_logit_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _eps)));
+  }|]
+
+special_logit_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_logit_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_logit_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_polygamma_lt
+  :: Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_polygamma_lt _n _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_polygamma(
+    $(int64_t _n)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_polygamma_out_tlt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_polygamma_out_tlt _out _n _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_polygamma_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_logsumexp_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+special_logsumexp_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_logsumexp(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+special_logsumexp_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+special_logsumexp_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_logsumexp(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+special_logsumexp_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+special_logsumexp_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_logsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+special_logsumexp_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+special_logsumexp_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_logsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+special_expit_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_expit_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_expit(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_expit_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_expit_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_expit_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_sinc_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_sinc_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_sinc(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_sinc_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_sinc_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_sinc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_round_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+special_round_tl _self _decimals =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_round(
+    *$(at::Tensor* _self)
+  , $(int64_t _decimals)));
+  }|]
+
+special_round_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_round_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_round(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_round_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+special_round_out_ttl _out _self _decimals =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_round_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _decimals)));
+  }|]
+
+special_round_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_round_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_round_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_log1p_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_log1p_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_log1p(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_log1p_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_log1p_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_log1p_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_log_softmax_tls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+special_log_softmax_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_log_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+special_log_softmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+special_log_softmax_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_log_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+special_gammainc_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_gammainc_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_gammainc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_gammainc_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_gammainc_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_gammainc(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_gammaincc_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_gammaincc_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_gammaincc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_gammaincc_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_gammaincc_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_gammaincc(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+special_multigammaln_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+special_multigammaln_tl _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_multigammaln(
+    *$(at::Tensor* _self)
+  , $(int64_t _p)));
+  }|]
+
+special_multigammaln_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+special_multigammaln_out_ttl _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_multigammaln_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _p)));
+  }|]
+
+special_softmax_tls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+special_softmax_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+special_softmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+special_softmax_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+fft_fft_tlls
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_fft_tlls _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_fft_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_fft_tll _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_fft_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_fft_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_fft_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_fft_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_fft_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_fft_out_ttlls _out _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_fft_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_fft_out_ttll _out _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_fft_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_fft_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_fft_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_fft_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_ifft_tlls
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ifft_tlls _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ifft_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_ifft_tll _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_ifft_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_ifft_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_ifft_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ifft_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_ifft_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ifft_out_ttlls _out _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ifft_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_ifft_out_ttll _out _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_ifft_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_ifft_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_ifft_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ifft_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_rfft_tlls
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_rfft_tlls _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_rfft_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_rfft_tll _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_rfft_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_rfft_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_rfft_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_rfft_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_rfft_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_rfft_out_ttlls _out _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_rfft_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_rfft_out_ttll _out _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_rfft_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_rfft_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native11.hs b/src/Torch/Internal/Unmanaged/Native/Native11.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native11.hs
@@ -0,0 +1,3308 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native11 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+fft_rfft_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_rfft_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_irfft_tlls
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_irfft_tlls _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_irfft_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_irfft_tll _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_irfft_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_irfft_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_irfft_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_irfft_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_irfft_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_irfft_out_ttlls _out _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_irfft_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_irfft_out_ttll _out _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_irfft_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_irfft_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_irfft_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_irfft_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_hfft_tlls
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_hfft_tlls _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_hfft_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_hfft_tll _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_hfft_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_hfft_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_hfft_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_hfft_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_hfft_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_hfft_out_ttlls _out _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_hfft_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_hfft_out_ttll _out _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_hfft_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_hfft_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_hfft_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_hfft_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_ihfft_tlls
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ihfft_tlls _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ihfft_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_ihfft_tll _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_ihfft_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_ihfft_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_ihfft_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ihfft_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_ihfft_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ihfft_out_ttlls _out _self _n _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ihfft_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_ihfft_out_ttll _out _self _n _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)
+  , $(int64_t _dim)));
+  }|]
+
+fft_ihfft_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_ihfft_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+fft_ihfft_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ihfft_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_fft2_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_fft2_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_fft2_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fft2_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_fft2_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fft2_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_fft2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_fft2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft2(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_fft2_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_fft2_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_fft2_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fft2_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_fft2_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fft2_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_fft2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_fft2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_ifft2_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ifft2_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ifft2_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifft2_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ifft2_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifft2_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_ifft2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ifft2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft2(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_ifft2_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ifft2_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ifft2_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifft2_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ifft2_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifft2_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_ifft2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ifft2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_rfft2_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_rfft2_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_rfft2_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_rfft2_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_rfft2_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_rfft2_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_rfft2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_rfft2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft2(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_rfft2_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_rfft2_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_rfft2_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_rfft2_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_rfft2_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_rfft2_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_rfft2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_rfft2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_irfft2_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_irfft2_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_irfft2_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_irfft2_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_irfft2_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_irfft2_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_irfft2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_irfft2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft2(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_irfft2_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_irfft2_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_irfft2_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_irfft2_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_irfft2_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_irfft2_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_irfft2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_irfft2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_hfft2_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_hfft2_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_hfft2_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_hfft2_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_hfft2_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_hfft2_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_hfft2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_hfft2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft2(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_hfft2_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_hfft2_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_hfft2_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_hfft2_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_hfft2_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_hfft2_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_hfft2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_hfft2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_ihfft2_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ihfft2_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ihfft2_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ihfft2_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ihfft2_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ihfft2_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft2(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_ihfft2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ihfft2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft2(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_ihfft2_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ihfft2_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ihfft2_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ihfft2_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ihfft2_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ihfft2_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_ihfft2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ihfft2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfft2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_fftn_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_fftn_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_fftn_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fftn_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_fftn_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fftn_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_fftn_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_fftn_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftn(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_fftn_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_fftn_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_fftn_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fftn_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_fftn_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fftn_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_fftn_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_fftn_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_ifftn_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ifftn_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ifftn_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifftn_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ifftn_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifftn_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_ifftn_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ifftn_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftn(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_ifftn_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ifftn_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ifftn_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifftn_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ifftn_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifftn_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_ifftn_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ifftn_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_rfftn_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_rfftn_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_rfftn_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_rfftn_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_rfftn_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_rfftn_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_rfftn_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_rfftn_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftn(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_rfftn_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_rfftn_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_rfftn_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_rfftn_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_rfftn_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_rfftn_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_rfftn_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_rfftn_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_irfftn_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_irfftn_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_irfftn_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_irfftn_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_irfftn_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_irfftn_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_irfftn_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_irfftn_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfftn(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_irfftn_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_irfftn_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_irfftn_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_irfftn_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_irfftn_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_irfftn_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_irfftn_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_irfftn_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_irfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_hfftn_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_hfftn_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_hfftn_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_hfftn_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_hfftn_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_hfftn_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_hfftn_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_hfftn_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfftn(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_hfftn_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_hfftn_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_hfftn_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_hfftn_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_hfftn_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_hfftn_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_hfftn_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_hfftn_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_hfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_ihfftn_tlls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ihfftn_tlls _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ihfftn_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ihfftn_tll _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ihfftn_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ihfftn_tl _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfftn(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_ihfftn_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ihfftn_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfftn(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_ihfftn_out_ttlls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+fft_ihfftn_out_ttlls _out _self _s _dim _norm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)
+  , *$(std::string* _norm)));
+  }|]
+
+fft_ihfftn_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ihfftn_out_ttll _out _self _s _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ihfftn_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ihfftn_out_ttl _out _self _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _s)));
+  }|]
+
+fft_ihfftn_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ihfftn_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ihfftn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fft_fftfreq_ldo
+  :: Int64
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+fft_fftfreq_ldo _n _d _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftfreq(
+    $(int64_t _n)
+  , $(double _d)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+fft_fftfreq_ld
+  :: Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+fft_fftfreq_ld _n _d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftfreq(
+    $(int64_t _n)
+  , $(double _d)));
+  }|]
+
+fft_fftfreq_l
+  :: Int64
+  -> IO (Ptr Tensor)
+fft_fftfreq_l _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftfreq(
+    $(int64_t _n)));
+  }|]
+
+fft_fftfreq_out_tld
+  :: Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+fft_fftfreq_out_tld _out _n _d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftfreq_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)
+  , $(double _d)));
+  }|]
+
+fft_fftfreq_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_fftfreq_out_tl _out _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftfreq_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)));
+  }|]
+
+fft_rfftfreq_ldo
+  :: Int64
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+fft_rfftfreq_ldo _n _d _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftfreq(
+    $(int64_t _n)
+  , $(double _d)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+fft_rfftfreq_ld
+  :: Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+fft_rfftfreq_ld _n _d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftfreq(
+    $(int64_t _n)
+  , $(double _d)));
+  }|]
+
+fft_rfftfreq_l
+  :: Int64
+  -> IO (Ptr Tensor)
+fft_rfftfreq_l _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftfreq(
+    $(int64_t _n)));
+  }|]
+
+fft_rfftfreq_out_tld
+  :: Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+fft_rfftfreq_out_tld _out _n _d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftfreq_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)
+  , $(double _d)));
+  }|]
+
+fft_rfftfreq_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+fft_rfftfreq_out_tl _out _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_rfftfreq_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)));
+  }|]
+
+fft_fftshift_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_fftshift_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftshift(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_fftshift_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_fftshift_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_fftshift(
+    *$(at::Tensor* _self)));
+  }|]
+
+fft_ifftshift_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+fft_ifftshift_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftshift(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+fft_ifftshift_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fft_ifftshift_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fft_ifftshift(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_cholesky_ex_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_tbb _self _upper _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_cholesky_ex(
+    *$(at::Tensor* _self)
+  , $(bool _upper)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_cholesky_ex_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_tb _self _upper =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_cholesky_ex(
+    *$(at::Tensor* _self)
+  , $(bool _upper)));
+  }|]
+
+linalg_cholesky_ex_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_cholesky_ex(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_cholesky_ex_out_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_out_tttbb _L _info _self _upper _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_cholesky_ex_out(
+    *$(at::Tensor* _L)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _self)
+  , $(bool _upper)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_cholesky_ex_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_out_tttb _L _info _self _upper =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_cholesky_ex_out(
+    *$(at::Tensor* _L)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _self)
+  , $(bool _upper)));
+  }|]
+
+linalg_cholesky_ex_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_cholesky_ex_out_ttt _L _info _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_cholesky_ex_out(
+    *$(at::Tensor* _L)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_cholesky_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_cholesky_tb _self _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cholesky(
+    *$(at::Tensor* _self)
+  , $(bool _upper)));
+  }|]
+
+linalg_cholesky_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_cholesky_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cholesky(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_cholesky_out_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_cholesky_out_ttb _out _self _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cholesky_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _upper)));
+  }|]
+
+linalg_cholesky_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_cholesky_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cholesky_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_cross_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_cross_ttl _self _other _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cross(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(int64_t _dim)));
+  }|]
+
+linalg_cross_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_cross_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cross(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+linalg_cross_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_cross_out_tttl _out _self _other _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cross_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(int64_t _dim)));
+  }|]
+
+linalg_cross_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_cross_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cross_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+linalg_lu_factor_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_lu_factor_tb _A _pivot =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_lu_factor(
+    *$(at::Tensor* _A)
+  , $(bool _pivot)));
+  }|]
+
+linalg_lu_factor_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_lu_factor_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_lu_factor(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_lu_factor_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_lu_factor_out_tttb _LU _pivots _A _pivot =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_lu_factor_out(
+    *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _A)
+  , $(bool _pivot)));
+  }|]
+
+linalg_lu_factor_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_lu_factor_out_ttt _LU _pivots _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_lu_factor_out(
+    *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_lu_factor_ex_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_tbb _A _pivot _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu_factor_ex(
+    *$(at::Tensor* _A)
+  , $(bool _pivot)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_lu_factor_ex_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_tb _A _pivot =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu_factor_ex(
+    *$(at::Tensor* _A)
+  , $(bool _pivot)));
+  }|]
+
+linalg_lu_factor_ex_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu_factor_ex(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_lu_factor_ex_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_out_ttttbb _LU _pivots _info _A _pivot _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu_factor_ex_out(
+    *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , $(bool _pivot)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_lu_factor_ex_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_out_ttttb _LU _pivots _info _A _pivot =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu_factor_ex_out(
+    *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , $(bool _pivot)));
+  }|]
+
+linalg_lu_factor_ex_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_factor_ex_out_tttt _LU _pivots _info _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu_factor_ex_out(
+    *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_lu_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_tb _A _pivot =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu(
+    *$(at::Tensor* _A)
+  , $(bool _pivot)));
+  }|]
+
+linalg_lu_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_lu_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_out_ttttb _P _L _U _A _pivot =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu_out(
+    *$(at::Tensor* _P)
+  , *$(at::Tensor* _L)
+  , *$(at::Tensor* _U)
+  , *$(at::Tensor* _A)
+  , $(bool _pivot)));
+  }|]
+
+linalg_lu_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_lu_out_tttt _P _L _U _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_lu_out(
+    *$(at::Tensor* _P)
+  , *$(at::Tensor* _L)
+  , *$(at::Tensor* _U)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_lu_solve_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_lu_solve_tttbb _LU _pivots _B _left _adjoint =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_lu_solve(
+    *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)
+  , $(bool _left)
+  , $(bool _adjoint)));
+  }|]
+
+linalg_lu_solve_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_lu_solve_tttb _LU _pivots _B _left =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_lu_solve(
+    *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)
+  , $(bool _left)));
+  }|]
+
+linalg_lu_solve_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_lu_solve_ttt _LU _pivots _B =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_lu_solve(
+    *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)));
+  }|]
+
+linalg_lu_solve_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_lu_solve_out_ttttbb _out _LU _pivots _B _left _adjoint =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_lu_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)
+  , $(bool _left)
+  , $(bool _adjoint)));
+  }|]
+
+linalg_lu_solve_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_lu_solve_out_ttttb _out _LU _pivots _B _left =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_lu_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)
+  , $(bool _left)));
+  }|]
+
+linalg_lu_solve_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_lu_solve_out_tttt _out _LU _pivots _B =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_lu_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)));
+  }|]
+
+_linalg_det_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_det_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_det(
+    *$(at::Tensor* _A)));
+  }|]
+
+_linalg_det_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_det_out_tttt _result _LU _pivots _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_det_out(
+    *$(at::Tensor* _result)
+  , *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_det_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_det_t _A =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_det(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_det_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_det_out_tt _out _A =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_det_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _A)));
+  }|]
+
+det_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+det_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::det(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_ldl_factor_ex_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_tbb _self _hermitian _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_ldl_factor_ex(
+    *$(at::Tensor* _self)
+  , $(bool _hermitian)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_ldl_factor_ex_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_tb _self _hermitian =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_ldl_factor_ex(
+    *$(at::Tensor* _self)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_ldl_factor_ex_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_ldl_factor_ex(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_ldl_factor_ex_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_out_ttttbb _LD _pivots _info _self _hermitian _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_ldl_factor_ex_out(
+    *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _self)
+  , $(bool _hermitian)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_ldl_factor_ex_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_out_ttttb _LD _pivots _info _self _hermitian =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_ldl_factor_ex_out(
+    *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _self)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_ldl_factor_ex_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_ldl_factor_ex_out_tttt _LD _pivots _info _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_ldl_factor_ex_out(
+    *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_ldl_factor_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_ldl_factor_tb _self _hermitian =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_ldl_factor(
+    *$(at::Tensor* _self)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_ldl_factor_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_ldl_factor_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_ldl_factor(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_ldl_factor_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_ldl_factor_out_tttb _LD _pivots _self _hermitian =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_ldl_factor_out(
+    *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _self)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_ldl_factor_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_ldl_factor_out_ttt _LD _pivots _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_ldl_factor_out(
+    *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_ldl_solve_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_ldl_solve_tttb _LD _pivots _B _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_ldl_solve(
+    *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_ldl_solve_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_ldl_solve_ttt _LD _pivots _B =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_ldl_solve(
+    *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)));
+  }|]
+
+linalg_ldl_solve_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_ldl_solve_out_ttttb _out _LD _pivots _B _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_ldl_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_ldl_solve_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_ldl_solve_out_tttt _out _LD _pivots _B =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_ldl_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _LD)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _B)));
+  }|]
+
+linalg_lstsq_ttds
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_ttds _self _b _rcond _driver =
+  [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::linalg_lstsq(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _b)
+  , $(double _rcond)
+  , *$(std::string* _driver)));
+  }|]
+
+linalg_lstsq_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_ttd _self _b _rcond =
+  [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::linalg_lstsq(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _b)
+  , $(double _rcond)));
+  }|]
+
+linalg_lstsq_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_tt _self _b =
+  [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::linalg_lstsq(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _b)));
+  }|]
+
+linalg_lstsq_out_ttttttds
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_out_ttttttds _solution _residuals _rank _singular_values _self _b _rcond _driver =
+  [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::linalg_lstsq_out(
+    *$(at::Tensor* _solution)
+  , *$(at::Tensor* _residuals)
+  , *$(at::Tensor* _rank)
+  , *$(at::Tensor* _singular_values)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _b)
+  , $(double _rcond)
+  , *$(std::string* _driver)));
+  }|]
+
+linalg_lstsq_out_ttttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_out_ttttttd _solution _residuals _rank _singular_values _self _b _rcond =
+  [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::linalg_lstsq_out(
+    *$(at::Tensor* _solution)
+  , *$(at::Tensor* _residuals)
+  , *$(at::Tensor* _rank)
+  , *$(at::Tensor* _singular_values)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _b)
+  , $(double _rcond)));
+  }|]
+
+linalg_lstsq_out_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+linalg_lstsq_out_tttttt _solution _residuals _rank _singular_values _self _b =
+  [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::linalg_lstsq_out(
+    *$(at::Tensor* _solution)
+  , *$(at::Tensor* _residuals)
+  , *$(at::Tensor* _rank)
+  , *$(at::Tensor* _singular_values)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _b)));
+  }|]
+
+linalg_matmul_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matmul_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matmul(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+linalg_matmul_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matmul_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matmul_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+linalg_vecdot_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_vecdot_ttl _x _y _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vecdot(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _y)
+  , $(int64_t _dim)));
+  }|]
+
+linalg_vecdot_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_vecdot_tt _x _y =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vecdot(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _y)));
+  }|]
+
+linalg_vecdot_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_vecdot_out_tttl _out _x _y _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vecdot_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _y)
+  , $(int64_t _dim)));
+  }|]
+
+linalg_vecdot_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_vecdot_out_ttt _out _x _y =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vecdot_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _y)));
+  }|]
+
+linalg_matrix_exp_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_exp_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_exp(
+    *$(at::Tensor* _self)));
+  }|]
+
+_linalg_slogdet_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_slogdet_t _A =
+  [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::_linalg_slogdet(
+    *$(at::Tensor* _A)));
+  }|]
+
+_linalg_slogdet_out_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_slogdet_out_ttttt _sign _logabsdet _LU _pivots _A =
+  [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::_linalg_slogdet_out(
+    *$(at::Tensor* _sign)
+  , *$(at::Tensor* _logabsdet)
+  , *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_slogdet_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_slogdet_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_slogdet(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_slogdet_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_slogdet_out_ttt _sign _logabsdet _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_slogdet_out(
+    *$(at::Tensor* _sign)
+  , *$(at::Tensor* _logabsdet)
+  , *$(at::Tensor* _A)));
+  }|]
+
+slogdet_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+slogdet_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::slogdet(
+    *$(at::Tensor* _self)));
+  }|]
+
+slogdet_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+slogdet_out_ttt _sign _logabsdet _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::slogdet_out(
+    *$(at::Tensor* _sign)
+  , *$(at::Tensor* _logabsdet)
+  , *$(at::Tensor* _self)));
+  }|]
+
+logdet_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+logdet_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logdet(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_eig_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_eig_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_eig(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_eig_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_eig_out_ttt _eigenvalues _eigenvectors _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_eig_out(
+    *$(at::Tensor* _eigenvalues)
+  , *$(at::Tensor* _eigenvectors)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_eigvals_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_eigvals_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_eigvals(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_eigvals_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_eigvals_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_eigvals_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_linalg_eigh_tsb
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_tsb _A _UPLO _compute_v =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_linalg_eigh(
+    *$(at::Tensor* _A)
+  , *$(std::string* _UPLO)
+  , $(bool _compute_v)));
+  }|]
+
+_linalg_eigh_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_ts _A _UPLO =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_linalg_eigh(
+    *$(at::Tensor* _A)
+  , *$(std::string* _UPLO)));
+  }|]
+
+_linalg_eigh_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_linalg_eigh(
+    *$(at::Tensor* _A)));
+  }|]
+
+_linalg_eigh_out_tttsb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_out_tttsb _eigenvalues _eigenvectors _A _UPLO _compute_v =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_linalg_eigh_out(
+    *$(at::Tensor* _eigenvalues)
+  , *$(at::Tensor* _eigenvectors)
+  , *$(at::Tensor* _A)
+  , *$(std::string* _UPLO)
+  , $(bool _compute_v)));
+  }|]
+
+_linalg_eigh_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_out_ttts _eigenvalues _eigenvectors _A _UPLO =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_linalg_eigh_out(
+    *$(at::Tensor* _eigenvalues)
+  , *$(at::Tensor* _eigenvectors)
+  , *$(at::Tensor* _A)
+  , *$(std::string* _UPLO)));
+  }|]
+
+_linalg_eigh_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_linalg_eigh_out_ttt _eigenvalues _eigenvectors _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_linalg_eigh_out(
+    *$(at::Tensor* _eigenvalues)
+  , *$(at::Tensor* _eigenvectors)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_eigh_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_eigh_ts _self _UPLO =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_eigh(
+    *$(at::Tensor* _self)
+  , *$(std::string* _UPLO)));
+  }|]
+
+linalg_eigh_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_eigh_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_eigh(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_eigh_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_eigh_out_ttts _eigvals _eigvecs _self _UPLO =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_eigh_out(
+    *$(at::Tensor* _eigvals)
+  , *$(at::Tensor* _eigvecs)
+  , *$(at::Tensor* _self)
+  , *$(std::string* _UPLO)));
+  }|]
+
+linalg_eigh_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_eigh_out_ttt _eigvals _eigvecs _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_eigh_out(
+    *$(at::Tensor* _eigvals)
+  , *$(at::Tensor* _eigvecs)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_eigvalsh_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+linalg_eigvalsh_ts _self _UPLO =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_eigvalsh(
+    *$(at::Tensor* _self)
+  , *$(std::string* _UPLO)));
+  }|]
+
+linalg_eigvalsh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_eigvalsh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_eigvalsh(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_eigvalsh_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+linalg_eigvalsh_out_tts _out _self _UPLO =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_eigvalsh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::string* _UPLO)));
+  }|]
+
+linalg_eigvalsh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_eigvalsh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_eigvalsh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_householder_product_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_householder_product_tt _input _tau =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_householder_product(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _tau)));
+  }|]
+
+linalg_householder_product_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_householder_product_out_ttt _out _input _tau =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_householder_product_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _tau)));
+  }|]
+
+linalg_inv_ex_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_inv_ex_tb _A _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_inv_ex(
+    *$(at::Tensor* _A)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_inv_ex_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_inv_ex_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_inv_ex(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_inv_ex_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_inv_ex_out_tttb _inverse _info _A _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_inv_ex_out(
+    *$(at::Tensor* _inverse)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_inv_ex_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_inv_ex_out_ttt _inverse _info _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_inv_ex_out(
+    *$(at::Tensor* _inverse)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_inv_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_inv_t _A =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_inv(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_inv_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_inv_out_tt _out _A =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_inv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _A)));
+  }|]
+
+inverse_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+inverse_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::inverse(
+    *$(at::Tensor* _self)));
+  }|]
+
+inverse_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+inverse_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::inverse_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+inner_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+inner_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::inner(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+inner_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+inner_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::inner_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+outer_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+outer_tt _self _vec2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::outer(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec2)));
+  }|]
+
+outer_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+outer_out_ttt _out _self _vec2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::outer_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec2)));
+  }|]
+
+ger_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ger_tt _self _vec2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ger(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec2)));
+  }|]
+
+ger_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ger_out_ttt _out _self _vec2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ger_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec2)));
+  }|]
+
+linalg_norm_tslbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+linalg_norm_tslbs _self _ord _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+linalg_norm_tslb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_norm_tslb _self _ord _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+linalg_norm_tsl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+linalg_norm_tsl _self _ord _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+linalg_norm_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+linalg_norm_ts _self _ord =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)));
+  }|]
+
+linalg_norm_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_norm_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_norm_out_ttslbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+linalg_norm_out_ttslbs _out _self _ord _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+linalg_norm_out_ttslb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_norm_out_ttslb _out _self _ord _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+linalg_norm_out_ttsl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+linalg_norm_out_ttsl _out _self _ord _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+linalg_norm_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+linalg_norm_out_tts _out _self _ord =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)));
+  }|]
+
+linalg_norm_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_norm_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_vector_norm_tslbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+linalg_vector_norm_tslbs _self _ord _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+linalg_vector_norm_tslb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_vector_norm_tslb _self _ord _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+linalg_vector_norm_tsl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+linalg_vector_norm_tsl _self _ord _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+linalg_vector_norm_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+linalg_vector_norm_ts _self _ord =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)));
+  }|]
+
+linalg_vector_norm_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_vector_norm_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_vector_norm_out_ttslbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+linalg_vector_norm_out_ttslbs _out _self _ord _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+linalg_vector_norm_out_ttslb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_vector_norm_out_ttslb _out _self _ord _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+linalg_vector_norm_out_ttsl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+linalg_vector_norm_out_ttsl _out _self _ord _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+linalg_vector_norm_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+linalg_vector_norm_out_tts _out _self _ord =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)));
+  }|]
+
+linalg_vector_norm_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_vector_norm_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vector_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_matrix_norm_tslbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_tslbs _self _ord _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+linalg_matrix_norm_tslb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_tslb _self _ord _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+linalg_matrix_norm_tsl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_tsl _self _ord _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+linalg_matrix_norm_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_ts _self _ord =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)));
+  }|]
+
+linalg_matrix_norm_out_ttslbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_out_ttslbs _out _self _ord _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+linalg_matrix_norm_out_ttslb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_out_ttslb _out _self _ord _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+linalg_matrix_norm_out_ttsl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_out_ttsl _out _self _ord _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+linalg_matrix_norm_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_out_tts _out _self _ord =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _ord)));
+  }|]
+
+linalg_matrix_norm_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_matrix_norm_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_norm_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_linalg_svd_tbbs
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_tbbs _A _full_matrices _compute_uv _driver =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd(
+    *$(at::Tensor* _A)
+  , $(bool _full_matrices)
+  , $(bool _compute_uv)
+  , *$(std::string* _driver)));
+  }|]
+
+_linalg_svd_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_tbb _A _full_matrices _compute_uv =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd(
+    *$(at::Tensor* _A)
+  , $(bool _full_matrices)
+  , $(bool _compute_uv)));
+  }|]
+
+_linalg_svd_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_tb _A _full_matrices =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd(
+    *$(at::Tensor* _A)
+  , $(bool _full_matrices)));
+  }|]
+
+_linalg_svd_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd(
+    *$(at::Tensor* _A)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native12.hs b/src/Torch/Internal/Unmanaged/Native/Native12.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native12.hs
@@ -0,0 +1,2986 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native12 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+_linalg_svd_out_ttttbbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_out_ttttbbs _U _S _Vh _A _full_matrices _compute_uv _driver =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _Vh)
+  , *$(at::Tensor* _A)
+  , $(bool _full_matrices)
+  , $(bool _compute_uv)
+  , *$(std::string* _driver)));
+  }|]
+
+_linalg_svd_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_out_ttttbb _U _S _Vh _A _full_matrices _compute_uv =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _Vh)
+  , *$(at::Tensor* _A)
+  , $(bool _full_matrices)
+  , $(bool _compute_uv)));
+  }|]
+
+_linalg_svd_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_out_ttttb _U _S _Vh _A _full_matrices =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _Vh)
+  , *$(at::Tensor* _A)
+  , $(bool _full_matrices)));
+  }|]
+
+_linalg_svd_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_linalg_svd_out_tttt _U _S _Vh _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _Vh)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_svd_tbs
+  :: Ptr Tensor
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_tbs _A _full_matrices _driver =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd(
+    *$(at::Tensor* _A)
+  , $(bool _full_matrices)
+  , *$(std::string* _driver)));
+  }|]
+
+linalg_svd_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_tb _A _full_matrices =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd(
+    *$(at::Tensor* _A)
+  , $(bool _full_matrices)));
+  }|]
+
+linalg_svd_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_svd_out_ttttbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_out_ttttbs _U _S _Vh _A _full_matrices _driver =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _Vh)
+  , *$(at::Tensor* _A)
+  , $(bool _full_matrices)
+  , *$(std::string* _driver)));
+  }|]
+
+linalg_svd_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_out_ttttb _U _S _Vh _A _full_matrices =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _Vh)
+  , *$(at::Tensor* _A)
+  , $(bool _full_matrices)));
+  }|]
+
+linalg_svd_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linalg_svd_out_tttt _U _S _Vh _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _Vh)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_svdvals_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+linalg_svdvals_ts _A _driver =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_svdvals(
+    *$(at::Tensor* _A)
+  , *$(std::string* _driver)));
+  }|]
+
+linalg_svdvals_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_svdvals_t _A =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_svdvals(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_svdvals_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+linalg_svdvals_out_tts _out _A _driver =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_svdvals_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _A)
+  , *$(std::string* _driver)));
+  }|]
+
+linalg_svdvals_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_svdvals_out_tt _out _A =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_svdvals_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_cond_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+linalg_cond_ts _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cond(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)));
+  }|]
+
+linalg_cond_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_cond_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cond(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_cond_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+linalg_cond_out_tts _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cond_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)));
+  }|]
+
+linalg_cond_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_cond_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cond_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_pinv_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_pinv_tttb _self _atol _rtol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _atol)
+  , *$(at::Tensor* _rtol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_pinv_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_pinv_ttt _self _atol _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _atol)
+  , *$(at::Tensor* _rtol)));
+  }|]
+
+linalg_pinv_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_pinv_tt _self _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _atol)));
+  }|]
+
+linalg_pinv_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_pinv_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_pinv_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_pinv_out_ttttb _out _self _atol _rtol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _atol)
+  , *$(at::Tensor* _rtol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_pinv_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_pinv_out_tttt _out _self _atol _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _atol)
+  , *$(at::Tensor* _rtol)));
+  }|]
+
+linalg_pinv_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_pinv_out_ttt _out _self _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _atol)));
+  }|]
+
+linalg_pinv_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_pinv_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_pinv_tddb
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_pinv_tddb _self _atol _rtol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)
+  , $(double _atol)
+  , $(double _rtol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_pinv_tdd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+linalg_pinv_tdd _self _atol _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)
+  , $(double _atol)
+  , $(double _rtol)));
+  }|]
+
+linalg_pinv_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+linalg_pinv_td _self _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)
+  , $(double _atol)));
+  }|]
+
+linalg_pinv_out_ttddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_pinv_out_ttddb _out _self _atol _rtol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _atol)
+  , $(double _rtol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_pinv_out_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+linalg_pinv_out_ttdd _out _self _atol _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _atol)
+  , $(double _rtol)));
+  }|]
+
+linalg_pinv_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+linalg_pinv_out_ttd _out _self _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _atol)));
+  }|]
+
+linalg_pinv_tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_pinv_tdb _self _rcond _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)
+  , $(double _rcond)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_pinv_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_pinv_ttb _self _rcond _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _rcond)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_pinv_out_ttdb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_pinv_out_ttdb _out _self _rcond _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _rcond)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_pinv_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_pinv_out_tttb _out _self _rcond _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _rcond)
+  , $(bool _hermitian)));
+  }|]
+
+_linalg_solve_ex_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_ttbb _A _B _left _check_errors =
+  [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::_linalg_solve_ex(
+    *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)
+  , $(bool _check_errors)));
+  }|]
+
+_linalg_solve_ex_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_ttb _A _B _left =
+  [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::_linalg_solve_ex(
+    *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)));
+  }|]
+
+_linalg_solve_ex_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_tt _A _B =
+  [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::_linalg_solve_ex(
+    *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)));
+  }|]
+
+_linalg_solve_ex_out_ttttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_out_ttttttbb _result _LU _pivots _info _A _B _left _check_errors =
+  [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::_linalg_solve_ex_out(
+    *$(at::Tensor* _result)
+  , *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)
+  , $(bool _check_errors)));
+  }|]
+
+_linalg_solve_ex_out_ttttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_out_ttttttb _result _LU _pivots _info _A _B _left =
+  [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::_linalg_solve_ex_out(
+    *$(at::Tensor* _result)
+  , *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)));
+  }|]
+
+_linalg_solve_ex_out_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_linalg_solve_ex_out_tttttt _result _LU _pivots _info _A _B =
+  [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::_linalg_solve_ex_out(
+    *$(at::Tensor* _result)
+  , *$(at::Tensor* _LU)
+  , *$(at::Tensor* _pivots)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)));
+  }|]
+
+linalg_solve_ex_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_ttbb _A _B _left _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex(
+    *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_solve_ex_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_ttb _A _B _left =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex(
+    *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)));
+  }|]
+
+linalg_solve_ex_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_tt _A _B =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex(
+    *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)));
+  }|]
+
+linalg_solve_ex_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_out_ttttbb _result _info _A _B _left _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex_out(
+    *$(at::Tensor* _result)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)
+  , $(bool _check_errors)));
+  }|]
+
+linalg_solve_ex_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_out_ttttb _result _info _A _B _left =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex_out(
+    *$(at::Tensor* _result)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)));
+  }|]
+
+linalg_solve_ex_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_solve_ex_out_tttt _result _info _A _B =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex_out(
+    *$(at::Tensor* _result)
+  , *$(at::Tensor* _info)
+  , *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)));
+  }|]
+
+linalg_solve_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_solve_ttb _A _B _left =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve(
+    *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)));
+  }|]
+
+linalg_solve_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_solve_tt _A _B =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve(
+    *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)));
+  }|]
+
+linalg_solve_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_solve_out_tttb _out _A _B _left =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)
+  , $(bool _left)));
+  }|]
+
+linalg_solve_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_solve_out_ttt _out _A _B =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _A)
+  , *$(at::Tensor* _B)));
+  }|]
+
+linalg_tensorinv_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_tensorinv_tl _self _ind =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorinv(
+    *$(at::Tensor* _self)
+  , $(int64_t _ind)));
+  }|]
+
+linalg_tensorinv_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_tensorinv_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorinv(
+    *$(at::Tensor* _self)));
+  }|]
+
+linalg_tensorinv_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_tensorinv_out_ttl _out _self _ind =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _ind)));
+  }|]
+
+linalg_tensorinv_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_tensorinv_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_tensorsolve_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+linalg_tensorsolve_ttl _self _other _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorsolve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+linalg_tensorsolve_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_tensorsolve_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorsolve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+linalg_tensorsolve_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+linalg_tensorsolve_out_tttl _out _self _other _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorsolve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+linalg_tensorsolve_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_tensorsolve_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorsolve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+linalg_qr_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_qr_ts _A _mode =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_qr(
+    *$(at::Tensor* _A)
+  , *$(std::string* _mode)));
+  }|]
+
+linalg_qr_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_qr_t _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_qr(
+    *$(at::Tensor* _A)));
+  }|]
+
+linalg_qr_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_qr_out_ttts _Q _R _A _mode =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_qr_out(
+    *$(at::Tensor* _Q)
+  , *$(at::Tensor* _R)
+  , *$(at::Tensor* _A)
+  , *$(std::string* _mode)));
+  }|]
+
+linalg_qr_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+linalg_qr_out_ttt _Q _R _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_qr_out(
+    *$(at::Tensor* _Q)
+  , *$(at::Tensor* _R)
+  , *$(at::Tensor* _A)));
+  }|]
+
+linalg_matrix_power_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_matrix_power_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_power(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+linalg_matrix_power_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_matrix_power_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_power_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+linalg_matrix_rank_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_tttb _input _atol _rtol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _atol)
+  , *$(at::Tensor* _rtol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_matrix_rank_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_ttt _input _atol _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _atol)
+  , *$(at::Tensor* _rtol)));
+  }|]
+
+linalg_matrix_rank_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_tt _input _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _atol)));
+  }|]
+
+linalg_matrix_rank_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_t _input =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _input)));
+  }|]
+
+linalg_matrix_rank_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_ttttb _out _input _atol _rtol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _atol)
+  , *$(at::Tensor* _rtol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_matrix_rank_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_tttt _out _input _atol _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _atol)
+  , *$(at::Tensor* _rtol)));
+  }|]
+
+linalg_matrix_rank_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_ttt _out _input _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _atol)));
+  }|]
+
+linalg_matrix_rank_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_tt _out _input =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)));
+  }|]
+
+linalg_matrix_rank_tddb
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_tddb _self _atol _rtol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _self)
+  , $(double _atol)
+  , $(double _rtol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_matrix_rank_tdd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_tdd _self _atol _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _self)
+  , $(double _atol)
+  , $(double _rtol)));
+  }|]
+
+linalg_matrix_rank_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_td _self _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _self)
+  , $(double _atol)));
+  }|]
+
+linalg_matrix_rank_out_ttddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_ttddb _out _self _atol _rtol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _atol)
+  , $(double _rtol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_matrix_rank_out_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_ttdd _out _self _atol _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _atol)
+  , $(double _rtol)));
+  }|]
+
+linalg_matrix_rank_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_ttd _out _self _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _atol)));
+  }|]
+
+linalg_matrix_rank_tdb
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_tdb _self _tol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _self)
+  , $(double _tol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_matrix_rank_out_ttdb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_ttdb _out _self _tol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _tol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_matrix_rank_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_ttb _input _tol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _tol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_matrix_rank_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_matrix_rank_out_tttb _out _input _tol _hermitian =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _tol)
+  , $(bool _hermitian)));
+  }|]
+
+linalg_multi_dot_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+linalg_multi_dot_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_multi_dot(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+linalg_multi_dot_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+linalg_multi_dot_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_multi_dot_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+nested_to_padded_tensor_tdl
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+nested_to_padded_tensor_tdl _self _padding _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nested_to_padded_tensor(
+    *$(at::Tensor* _self)
+  , $(double _padding)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+nested_to_padded_tensor_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+nested_to_padded_tensor_td _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nested_to_padded_tensor(
+    *$(at::Tensor* _self)
+  , $(double _padding)));
+  }|]
+
+_test_serialization_subcmul_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_test_serialization_subcmul_tts _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_serialization_subcmul(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_test_serialization_subcmul_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_serialization_subcmul_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_serialization_subcmul(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+_test_optional_intlist_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_test_optional_intlist_tl _values _addends =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_intlist(
+    *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _addends)));
+  }|]
+
+_test_optional_filled_intlist_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_test_optional_filled_intlist_tl _values _addends =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_filled_intlist(
+    *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _addends)));
+  }|]
+
+_test_optional_floatlist_ta
+  :: Ptr Tensor
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_test_optional_floatlist_ta _values _addends =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_floatlist(
+    *$(at::Tensor* _values)
+  , *$(std::vector<double>* _addends)));
+  }|]
+
+_test_string_default_tss
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+_test_string_default_tss _dummy _a _b =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_string_default(
+    *$(at::Tensor* _dummy)
+  , *$(std::string* _a)
+  , *$(std::string* _b)));
+  }|]
+
+_test_string_default_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+_test_string_default_ts _dummy _a =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_string_default(
+    *$(at::Tensor* _dummy)
+  , *$(std::string* _a)));
+  }|]
+
+_test_string_default_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_string_default_t _dummy =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_string_default(
+    *$(at::Tensor* _dummy)));
+  }|]
+
+_test_ambiguous_defaults_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_test_ambiguous_defaults_tll _dummy _a _b =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_ambiguous_defaults(
+    *$(at::Tensor* _dummy)
+  , $(int64_t _a)
+  , $(int64_t _b)));
+  }|]
+
+_test_ambiguous_defaults_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_test_ambiguous_defaults_tl _dummy _a =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_ambiguous_defaults(
+    *$(at::Tensor* _dummy)
+  , $(int64_t _a)));
+  }|]
+
+_test_ambiguous_defaults_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_ambiguous_defaults_t _dummy =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_ambiguous_defaults(
+    *$(at::Tensor* _dummy)));
+  }|]
+
+_test_ambiguous_defaults_tls
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+_test_ambiguous_defaults_tls _dummy _a _b =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_ambiguous_defaults(
+    *$(at::Tensor* _dummy)
+  , $(int64_t _a)
+  , *$(std::string* _b)));
+  }|]
+
+_test_warn_in_autograd_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_warn_in_autograd_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_warn_in_autograd(
+    *$(at::Tensor* _self)));
+  }|]
+
+_test_autograd_multiple_dispatch_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_autograd_multiple_dispatch_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_autograd_multiple_dispatch(
+    *$(at::Tensor* _self)));
+  }|]
+
+_test_autograd_multiple_dispatch_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_test_autograd_multiple_dispatch_tb _self _b =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_autograd_multiple_dispatch(
+    *$(at::Tensor* _self)
+  , $(bool _b)));
+  }|]
+
+_test_autograd_multiple_dispatch_view_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_autograd_multiple_dispatch_view_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_autograd_multiple_dispatch_view(
+    *$(at::Tensor* _self)));
+  }|]
+
+_test_autograd_multiple_dispatch_view_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_autograd_multiple_dispatch_view_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_autograd_multiple_dispatch_view_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+segment_reduce_tstttlbs
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+segment_reduce_tstttlbs _data _reduce _lengths _indices _offsets _axis _unsafe _initial =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
+    *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)
+  , $(bool _unsafe)
+  , *$(at::Scalar* _initial)));
+  }|]
+
+segment_reduce_tstttlb
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+segment_reduce_tstttlb _data _reduce _lengths _indices _offsets _axis _unsafe =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
+    *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)
+  , $(bool _unsafe)));
+  }|]
+
+segment_reduce_tstttl
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+segment_reduce_tstttl _data _reduce _lengths _indices _offsets _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
+    *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)));
+  }|]
+
+segment_reduce_tsttt
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+segment_reduce_tsttt _data _reduce _lengths _indices _offsets =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
+    *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)));
+  }|]
+
+segment_reduce_tstt
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+segment_reduce_tstt _data _reduce _lengths _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
+    *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+segment_reduce_tst
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+segment_reduce_tst _data _reduce _lengths =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
+    *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)));
+  }|]
+
+segment_reduce_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+segment_reduce_ts _data _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
+    *$(at::Tensor* _data)
+  , *$(std::string* _reduce)));
+  }|]
+
+_segment_reduce_backward_tttsttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_tttsttls _grad _output _data _reduce _lengths _offsets _axis _initial =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)
+  , *$(at::Scalar* _initial)));
+  }|]
+
+_segment_reduce_backward_tttsttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_tttsttl _grad _output _data _reduce _lengths _offsets _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)));
+  }|]
+
+_segment_reduce_backward_tttstt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_tttstt _grad _output _data _reduce _lengths _offsets =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _offsets)));
+  }|]
+
+_segment_reduce_backward_tttst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_tttst _grad _output _data _reduce _lengths =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)));
+  }|]
+
+_segment_reduce_backward_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_ttts _grad _output _data _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)));
+  }|]
+
+pad_sequence_lbd
+  :: Ptr TensorList
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+pad_sequence_lbd _sequences _batch_first _padding_value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pad_sequence(
+    *$(std::vector<at::Tensor>* _sequences)
+  , $(bool _batch_first)
+  , $(double _padding_value)));
+  }|]
+
+pad_sequence_lb
+  :: Ptr TensorList
+  -> CBool
+  -> IO (Ptr Tensor)
+pad_sequence_lb _sequences _batch_first =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pad_sequence(
+    *$(std::vector<at::Tensor>* _sequences)
+  , $(bool _batch_first)));
+  }|]
+
+pad_sequence_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+pad_sequence_l _sequences =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pad_sequence(
+    *$(std::vector<at::Tensor>* _sequences)));
+  }|]
+
+flatten_dense_tensors_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+flatten_dense_tensors_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flatten_dense_tensors(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+unflatten_dense_tensors_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+unflatten_dense_tensors_tl _flat _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unflatten_dense_tensors(
+    *$(at::Tensor* _flat)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+_nested_tensor_from_tensor_list_lsLDb
+  :: Ptr TensorList
+  -> ScalarType
+  -> Layout
+  -> DeviceType
+  -> CBool
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_lsLDb _list _dtype _layout _device _pin_memory =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
+    *$(std::vector<at::Tensor>* _list)
+  , $(at::ScalarType _dtype)
+  , $(at::Layout _layout)
+  , $(at::DeviceType _device)
+  , $(bool _pin_memory)));
+  }|]
+
+_nested_tensor_from_tensor_list_lsLD
+  :: Ptr TensorList
+  -> ScalarType
+  -> Layout
+  -> DeviceType
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_lsLD _list _dtype _layout _device =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
+    *$(std::vector<at::Tensor>* _list)
+  , $(at::ScalarType _dtype)
+  , $(at::Layout _layout)
+  , $(at::DeviceType _device)));
+  }|]
+
+_nested_tensor_from_tensor_list_lsL
+  :: Ptr TensorList
+  -> ScalarType
+  -> Layout
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_lsL _list _dtype _layout =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
+    *$(std::vector<at::Tensor>* _list)
+  , $(at::ScalarType _dtype)
+  , $(at::Layout _layout)));
+  }|]
+
+_nested_tensor_from_tensor_list_ls
+  :: Ptr TensorList
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_ls _list _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
+    *$(std::vector<at::Tensor>* _list)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_nested_tensor_from_tensor_list_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_l _list =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
+    *$(std::vector<at::Tensor>* _list)));
+  }|]
+
+_fw_primal_copy_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_fw_primal_copy_tl _self _level =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fw_primal_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _level)));
+  }|]
+
+_make_dual_copy_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_make_dual_copy_ttl _primal _tangent _level =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_dual_copy(
+    *$(at::Tensor* _primal)
+  , *$(at::Tensor* _tangent)
+  , $(int64_t _level)));
+  }|]
+
+view_as_real_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+view_as_real_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_as_real_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+view_as_complex_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+view_as_complex_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_as_complex_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+_conj_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_conj_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_conj_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+_neg_view_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_neg_view_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_neg_view_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+as_strided_copy_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+as_strided_copy_tlll _self _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+as_strided_copy_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+as_strided_copy_tll _self _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+_sparse_broadcast_to_copy_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_broadcast_to_copy_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_broadcast_to_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+diagonal_copy_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_copy_tlll _self _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+diagonal_copy_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_copy_tll _self _offset _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)));
+  }|]
+
+diagonal_copy_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_copy_tl _self _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _offset)));
+  }|]
+
+diagonal_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+diagonal_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+expand_copy_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+expand_copy_tlb _self _size _implicit =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expand_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(bool _implicit)));
+  }|]
+
+expand_copy_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+expand_copy_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expand_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+permute_copy_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+permute_copy_tl _self _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::permute_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+_reshape_alias_copy_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_reshape_alias_copy_tll _self _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_reshape_alias_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+select_copy_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+select_copy_tll _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+detach_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+detach_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::detach_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+slice_copy_tllll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_copy_tllll _self _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+slice_copy_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_copy_tlll _self _dim _start _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)));
+  }|]
+
+slice_copy_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_copy_tll _self _dim _start =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)));
+  }|]
+
+slice_copy_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_copy_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+slice_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+slice_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+split_copy_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+split_copy_tll _self _split_size _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _split_size)
+  , $(int64_t _dim)));
+  }|]
+
+split_copy_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+split_copy_tl _self _split_size =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _split_size)));
+  }|]
+
+split_with_sizes_copy_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr TensorList)
+split_with_sizes_copy_tll _self _split_sizes _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_with_sizes_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)
+  , $(int64_t _dim)));
+  }|]
+
+split_with_sizes_copy_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr TensorList)
+split_with_sizes_copy_tl _self _split_sizes =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_with_sizes_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)));
+  }|]
+
+squeeze_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+squeeze_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::squeeze_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+squeeze_copy_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+squeeze_copy_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::squeeze_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+t_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+t_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::t_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+transpose_copy_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+transpose_copy_tll _self _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::transpose_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+unsqueeze_copy_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+unsqueeze_copy_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unsqueeze_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+_indices_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_indices_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_indices_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+_values_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_values_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_values_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+indices_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+indices_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::indices_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+values_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+values_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::values_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+crow_indices_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+crow_indices_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::crow_indices_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+col_indices_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+col_indices_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::col_indices_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+ccol_indices_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+ccol_indices_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ccol_indices_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+row_indices_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+row_indices_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::row_indices_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+unbind_copy_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+unbind_copy_tl _self _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unbind_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+unbind_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr TensorList)
+unbind_copy_t _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unbind_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+unbind_copy_out_ltl
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Int64
+  -> IO (())
+unbind_copy_out_ltl _out _self _dim =
+  [C.throwBlock| void {  (at::unbind_copy_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+unbind_copy_out_lt
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> IO (())
+unbind_copy_out_lt _out _self =
+  [C.throwBlock| void {  (at::unbind_copy_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+split_copy_out_ltll
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (())
+split_copy_out_ltll _out _self _split_size _dim =
+  [C.throwBlock| void {  (at::split_copy_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _split_size)
+  , $(int64_t _dim)));
+  }|]
+
+split_copy_out_ltl
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Int64
+  -> IO (())
+split_copy_out_ltl _out _self _split_size =
+  [C.throwBlock| void {  (at::split_copy_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _split_size)));
+  }|]
+
+split_with_sizes_copy_out_ltll
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (())
+split_with_sizes_copy_out_ltll _out _self _split_sizes _dim =
+  [C.throwBlock| void {  (at::split_with_sizes_copy_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)
+  , $(int64_t _dim)));
+  }|]
+
+split_with_sizes_copy_out_ltl
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+split_with_sizes_copy_out_ltl _out _self _split_sizes =
+  [C.throwBlock| void {  (at::split_with_sizes_copy_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)));
+  }|]
+
+view_copy_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+view_copy_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+view_copy_ts
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+view_copy_ts _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_copy(
+    *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+unfold_copy_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+unfold_copy_tlll _self _dimension _size _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unfold_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dimension)
+  , $(int64_t _size)
+  , $(int64_t _step)));
+  }|]
+
+alias_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+alias_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::alias_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+_nested_tensor_softmax_with_shape_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_tensor_softmax_with_shape_tt _self _query =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_softmax_with_shape(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _query)));
+  }|]
+
+_transformer_encoder_layer_fwd_tllttttbbdtttttttttl
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_transformer_encoder_layer_fwd_tllttttbbdtttttttttl _src _embed_dim _num_heads _qkv_weight _qkv_bias _proj_weight _proj_bias _use_gelu _norm_first _eps _norm_weight_1 _norm_bias_1 _norm_weight_2 _norm_bias_2 _ffn_weight_1 _ffn_bias_1 _ffn_weight_2 _ffn_bias_2 _mask _mask_type =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd(
+    *$(at::Tensor* _src)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_heads)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , $(bool _use_gelu)
+  , $(bool _norm_first)
+  , $(double _eps)
+  , *$(at::Tensor* _norm_weight_1)
+  , *$(at::Tensor* _norm_bias_1)
+  , *$(at::Tensor* _norm_weight_2)
+  , *$(at::Tensor* _norm_bias_2)
+  , *$(at::Tensor* _ffn_weight_1)
+  , *$(at::Tensor* _ffn_bias_1)
+  , *$(at::Tensor* _ffn_weight_2)
+  , *$(at::Tensor* _ffn_bias_2)
+  , *$(at::Tensor* _mask)
+  , $(int64_t _mask_type)));
+  }|]
+
+_transformer_encoder_layer_fwd_tllttttbbdttttttttt
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_transformer_encoder_layer_fwd_tllttttbbdttttttttt _src _embed_dim _num_heads _qkv_weight _qkv_bias _proj_weight _proj_bias _use_gelu _norm_first _eps _norm_weight_1 _norm_bias_1 _norm_weight_2 _norm_bias_2 _ffn_weight_1 _ffn_bias_1 _ffn_weight_2 _ffn_bias_2 _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd(
+    *$(at::Tensor* _src)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_heads)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , $(bool _use_gelu)
+  , $(bool _norm_first)
+  , $(double _eps)
+  , *$(at::Tensor* _norm_weight_1)
+  , *$(at::Tensor* _norm_bias_1)
+  , *$(at::Tensor* _norm_weight_2)
+  , *$(at::Tensor* _norm_bias_2)
+  , *$(at::Tensor* _ffn_weight_1)
+  , *$(at::Tensor* _ffn_bias_1)
+  , *$(at::Tensor* _ffn_weight_2)
+  , *$(at::Tensor* _ffn_bias_2)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_transformer_encoder_layer_fwd_tllttttbbdtttttttt
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_transformer_encoder_layer_fwd_tllttttbbdtttttttt _src _embed_dim _num_heads _qkv_weight _qkv_bias _proj_weight _proj_bias _use_gelu _norm_first _eps _norm_weight_1 _norm_bias_1 _norm_weight_2 _norm_bias_2 _ffn_weight_1 _ffn_bias_1 _ffn_weight_2 _ffn_bias_2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd(
+    *$(at::Tensor* _src)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_heads)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , $(bool _use_gelu)
+  , $(bool _norm_first)
+  , $(double _eps)
+  , *$(at::Tensor* _norm_weight_1)
+  , *$(at::Tensor* _norm_bias_1)
+  , *$(at::Tensor* _norm_weight_2)
+  , *$(at::Tensor* _norm_bias_2)
+  , *$(at::Tensor* _ffn_weight_1)
+  , *$(at::Tensor* _ffn_bias_1)
+  , *$(at::Tensor* _ffn_weight_2)
+  , *$(at::Tensor* _ffn_bias_2)));
+  }|]
+
+_native_multi_head_attention_tttlltttttbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttlltttttbbl _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask _need_weights _average_attn_weights _mask_type =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)
+  , $(bool _need_weights)
+  , $(bool _average_attn_weights)
+  , $(int64_t _mask_type)));
+  }|]
+
+_native_multi_head_attention_tttlltttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttlltttttbb _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask _need_weights _average_attn_weights =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)
+  , $(bool _need_weights)
+  , $(bool _average_attn_weights)));
+  }|]
+
+_native_multi_head_attention_tttlltttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttlltttttb _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask _need_weights =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)
+  , $(bool _need_weights)));
+  }|]
+
+_native_multi_head_attention_tttllttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttllttttt _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_native_multi_head_attention_tttlltttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_tttlltttt _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)));
+  }|]
+
+scaled_dot_product_attention_ttttdb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+scaled_dot_product_attention_ttttdb _query _key _value _attn_mask _dropout_p _is_causal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scaled_dot_product_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , *$(at::Tensor* _attn_mask)
+  , $(double _dropout_p)
+  , $(bool _is_causal)));
+  }|]
+
+scaled_dot_product_attention_ttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+scaled_dot_product_attention_ttttd _query _key _value _attn_mask _dropout_p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scaled_dot_product_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , *$(at::Tensor* _attn_mask)
+  , $(double _dropout_p)));
+  }|]
+
+scaled_dot_product_attention_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+scaled_dot_product_attention_tttt _query _key _value _attn_mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scaled_dot_product_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , *$(at::Tensor* _attn_mask)));
+  }|]
+
+scaled_dot_product_attention_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+scaled_dot_product_attention_ttt _query _key _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scaled_dot_product_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)));
+  }|]
+
+_fused_sdp_choice_ttttdb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Int64)
+_fused_sdp_choice_ttttdb _query _key _value _attn_mask _dropout_p _is_causal =
+  [C.throwBlock| int64_t { return (at::_fused_sdp_choice(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , *$(at::Tensor* _attn_mask)
+  , $(double _dropout_p)
+  , $(bool _is_causal)));
+  }|]
+
+_fused_sdp_choice_ttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Int64)
+_fused_sdp_choice_ttttd _query _key _value _attn_mask _dropout_p =
+  [C.throwBlock| int64_t { return (at::_fused_sdp_choice(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , *$(at::Tensor* _attn_mask)
+  , $(double _dropout_p)));
+  }|]
+
+_fused_sdp_choice_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Int64)
+_fused_sdp_choice_tttt _query _key _value _attn_mask =
+  [C.throwBlock| int64_t { return (at::_fused_sdp_choice(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , *$(at::Tensor* _attn_mask)));
+  }|]
+
+_fused_sdp_choice_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Int64)
+_fused_sdp_choice_ttt _query _key _value =
+  [C.throwBlock| int64_t { return (at::_fused_sdp_choice(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)));
+  }|]
+
+_triton_scaled_dot_attention_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+_triton_scaled_dot_attention_tttd _q _k _v _dropout_p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_scaled_dot_attention(
+    *$(at::Tensor* _q)
+  , *$(at::Tensor* _k)
+  , *$(at::Tensor* _v)
+  , $(double _dropout_p)));
+  }|]
+
+_triton_scaled_dot_attention_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_triton_scaled_dot_attention_ttt _q _k _v =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_scaled_dot_attention(
+    *$(at::Tensor* _q)
+  , *$(at::Tensor* _k)
+  , *$(at::Tensor* _v)));
+  }|]
+
+_triton_multi_head_attention_tttllttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_triton_multi_head_attention_tttllttttt _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_multi_head_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_triton_multi_head_attention_tttlltttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_triton_multi_head_attention_tttlltttt _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_multi_head_attention(
+    *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)));
+  }|]
+
+special_airy_ai_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_airy_ai_t _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_airy_ai(
+    *$(at::Tensor* _x)));
+  }|]
+
+special_airy_ai_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_airy_ai_out_tt _out _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_airy_ai_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)));
+  }|]
+
+special_bessel_j0_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_bessel_j0_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_bessel_j0(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_bessel_j0_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_bessel_j0_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_bessel_j0_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_bessel_j1_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_bessel_j1_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_bessel_j1(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_bessel_j1_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_bessel_j1_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_bessel_j1_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_bessel_y0_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_bessel_y0_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_bessel_y0(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_bessel_y0_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_bessel_y0_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_bessel_y0_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_bessel_y1_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_bessel_y1_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_bessel_y1(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_bessel_y1_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_bessel_y1_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_bessel_y1_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_chebyshev_polynomial_t_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_t_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_t_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_t_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_t_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_t_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_chebyshev_polynomial_t_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_t_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_t_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_t_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_t_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_t_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_chebyshev_polynomial_u_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_u_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_u_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_u_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_u_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_u_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_chebyshev_polynomial_u_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_u_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_u_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_u_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_u_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_u_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_chebyshev_polynomial_v_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_v_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_v_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_v_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_v_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_v_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_chebyshev_polynomial_v_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_v_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_v_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_v_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_v_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_v_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_chebyshev_polynomial_w_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_w_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_w_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_w_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_w_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_w_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_chebyshev_polynomial_w_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_w_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_w_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_w_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_chebyshev_polynomial_w_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_chebyshev_polynomial_w_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native13.hs b/src/Torch/Internal/Unmanaged/Native/Native13.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native13.hs
@@ -0,0 +1,4830 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native13 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+special_hermite_polynomial_h_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_h_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_h(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_hermite_polynomial_h_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_h_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_h(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_hermite_polynomial_h_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_h_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_h(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_hermite_polynomial_h_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_h_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_h_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_hermite_polynomial_h_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_h_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_h_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_hermite_polynomial_h_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_h_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_h_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_hermite_polynomial_he_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_he_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_he(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_hermite_polynomial_he_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_he_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_he(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_hermite_polynomial_he_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_he_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_he(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_hermite_polynomial_he_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_he_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_he_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_hermite_polynomial_he_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_he_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_he_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_hermite_polynomial_he_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_hermite_polynomial_he_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_hermite_polynomial_he_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_laguerre_polynomial_l_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_laguerre_polynomial_l_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_laguerre_polynomial_l(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_laguerre_polynomial_l_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_laguerre_polynomial_l_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_laguerre_polynomial_l(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_laguerre_polynomial_l_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_laguerre_polynomial_l_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_laguerre_polynomial_l(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_laguerre_polynomial_l_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_laguerre_polynomial_l_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_laguerre_polynomial_l_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_laguerre_polynomial_l_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_laguerre_polynomial_l_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_laguerre_polynomial_l_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_laguerre_polynomial_l_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_laguerre_polynomial_l_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_laguerre_polynomial_l_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_legendre_polynomial_p_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_legendre_polynomial_p_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_legendre_polynomial_p(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_legendre_polynomial_p_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_legendre_polynomial_p_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_legendre_polynomial_p(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_legendre_polynomial_p_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_legendre_polynomial_p_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_legendre_polynomial_p(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_legendre_polynomial_p_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_legendre_polynomial_p_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_legendre_polynomial_p_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_legendre_polynomial_p_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_legendre_polynomial_p_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_legendre_polynomial_p_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_legendre_polynomial_p_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_legendre_polynomial_p_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_legendre_polynomial_p_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_modified_bessel_i0_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_modified_bessel_i0_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_modified_bessel_i0(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_modified_bessel_i0_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_modified_bessel_i0_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_modified_bessel_i0_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_modified_bessel_i1_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_modified_bessel_i1_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_modified_bessel_i1(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_modified_bessel_i1_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_modified_bessel_i1_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_modified_bessel_i1_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_modified_bessel_k0_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_modified_bessel_k0_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_modified_bessel_k0(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_modified_bessel_k0_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_modified_bessel_k0_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_modified_bessel_k0_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_modified_bessel_k1_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_modified_bessel_k1_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_modified_bessel_k1(
+    *$(at::Tensor* _self)));
+  }|]
+
+special_modified_bessel_k1_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_modified_bessel_k1_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_modified_bessel_k1_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+special_scaled_modified_bessel_k0_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_scaled_modified_bessel_k0_t _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_scaled_modified_bessel_k0(
+    *$(at::Tensor* _x)));
+  }|]
+
+special_scaled_modified_bessel_k0_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_scaled_modified_bessel_k0_out_tt _out _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_scaled_modified_bessel_k0_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)));
+  }|]
+
+special_scaled_modified_bessel_k1_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_scaled_modified_bessel_k1_t _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_scaled_modified_bessel_k1(
+    *$(at::Tensor* _x)));
+  }|]
+
+special_scaled_modified_bessel_k1_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_scaled_modified_bessel_k1_out_tt _out _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_scaled_modified_bessel_k1_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)));
+  }|]
+
+special_shifted_chebyshev_polynomial_t_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_t_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_t(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_t_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_t_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_t(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_t_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_t_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_t(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_t_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_t_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_t_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_t_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_t_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_t_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_t_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_t_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_t_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_u_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_u_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_u(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_u_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_u_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_u(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_u_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_u_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_u(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_u_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_u_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_u_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_u_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_u_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_u_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_u_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_u_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_u_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_v_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_v_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_v(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_v_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_v_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_v(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_v_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_v_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_v(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_v_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_v_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_v_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_v_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_v_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_v_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_v_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_v_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_v_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_w_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_w_tt _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_w(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_w_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_w_st _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_w(
+    *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_w_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_w_ts _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_w(
+    *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_w_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_w_out_ttt _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_w_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_w_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_w_out_tst _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_w_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _x)
+  , *$(at::Tensor* _n)));
+  }|]
+
+special_shifted_chebyshev_polynomial_w_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+special_shifted_chebyshev_polynomial_w_out_tts _out _x _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_shifted_chebyshev_polynomial_w_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Scalar* _n)));
+  }|]
+
+special_spherical_bessel_j0_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+special_spherical_bessel_j0_t _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_spherical_bessel_j0(
+    *$(at::Tensor* _x)));
+  }|]
+
+special_spherical_bessel_j0_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+special_spherical_bessel_j0_out_tt _out _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_spherical_bessel_j0_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)));
+  }|]
+
+_foobar_tbbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_foobar_tbbb _self _arg1 _arg2 _arg3 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_foobar(
+    *$(at::Tensor* _self)
+  , $(bool _arg1)
+  , $(bool _arg2)
+  , $(bool _arg3)));
+  }|]
+
+_foobar_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_foobar_tbb _self _arg1 _arg2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_foobar(
+    *$(at::Tensor* _self)
+  , $(bool _arg1)
+  , $(bool _arg2)));
+  }|]
+
+_foobar_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_foobar_tb _self _arg1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_foobar(
+    *$(at::Tensor* _self)
+  , $(bool _arg1)));
+  }|]
+
+_foobar_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_foobar_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_foobar(
+    *$(at::Tensor* _self)));
+  }|]
+
+_fused_adam__lllllldddddbbtt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+_fused_adam__lllllldddddbbtt _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale _found_inf =
+  [C.throwBlock| void {  (at::_fused_adam_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)
+  , *$(at::Tensor* _found_inf)));
+  }|]
+
+_fused_adam__lllllldddddbbt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> IO (())
+_fused_adam__lllllldddddbbt _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale =
+  [C.throwBlock| void {  (at::_fused_adam_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)));
+  }|]
+
+_fused_adam__lllllldddddbb
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (())
+_fused_adam__lllllldddddbb _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize =
+  [C.throwBlock| void {  (at::_fused_adam_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)));
+  }|]
+
+_fused_adamw__lllllldddddbbtt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+_fused_adamw__lllllldddddbbtt _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale _found_inf =
+  [C.throwBlock| void {  (at::_fused_adamw_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)
+  , *$(at::Tensor* _found_inf)));
+  }|]
+
+_fused_adamw__lllllldddddbbt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> IO (())
+_fused_adamw__lllllldddddbbt _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale =
+  [C.throwBlock| void {  (at::_fused_adamw_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)));
+  }|]
+
+_fused_adamw__lllllldddddbb
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (())
+_fused_adamw__lllllldddddbb _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize =
+  [C.throwBlock| void {  (at::_fused_adamw_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)));
+  }|]
+
+_new_zeros_with_same_feature_meta_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_new_zeros_with_same_feature_meta_out_tttl _out _self _other _self_num_batch_dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_new_zeros_with_same_feature_meta_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(int64_t _self_num_batch_dims)));
+  }|]
+
+_new_zeros_with_same_feature_meta_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_new_zeros_with_same_feature_meta_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_new_zeros_with_same_feature_meta_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+_cudnn_ctc_loss_out_ttttlllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_cudnn_ctc_loss_out_ttttlllbb _out0 _out1 _log_probs _targets _input_lengths _target_lengths _blank _deterministic _zero_infinity =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_cudnn_ctc_loss_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)
+  , $(bool _deterministic)
+  , $(bool _zero_infinity)));
+  }|]
+
+_cudnn_rnn_flatten_weight_out_tlllllllbb
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_cudnn_rnn_flatten_weight_out_tlllllllbb _out _weight_arr _weight_stride0 _input_size _mode _hidden_size _proj_size _num_layers _batch_first _bidirectional =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cudnn_rnn_flatten_weight_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _weight_arr)
+  , $(int64_t _weight_stride0)
+  , $(int64_t _input_size)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _proj_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(bool _bidirectional)));
+  }|]
+
+_cudnn_rnn_out_ttttttlltttllllbdbblt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_cudnn_rnn_out_ttttttlltttllllbdbblt _out0 _out1 _out2 _out3 _out4 _input _weight _weight_stride0 _weight_buf _hx _cx _mode _hidden_size _proj_size _num_layers _batch_first _dropout _train _bidirectional _batch_sizes _dropout_state =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_cudnn_rnn_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _out4)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _weight)
+  , $(int64_t _weight_stride0)
+  , *$(at::Tensor* _weight_buf)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _cx)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _proj_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , *$(at::Tensor* _dropout_state)));
+  }|]
+
+_cudnn_rnn_backward_out_tttltlltttttttllllbdbbltta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,4))
+  -> IO (())
+_cudnn_rnn_backward_out_tttltlltttttttllllbdbbltta _out0 _out1 _out2 _out3 _input _weight _weight_stride0 _weight_buf _hx _cx _output _grad_output _grad_hy _grad_cy _mode _hidden_size _proj_size _num_layers _batch_first _dropout _train _bidirectional _batch_sizes _dropout_state _reserve _output_mask =
+  [C.throwBlock| void {  (at::_cudnn_rnn_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(std::vector<at::Tensor>* _out3)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _weight)
+  , $(int64_t _weight_stride0)
+  , *$(at::Tensor* _weight_buf)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _proj_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , *$(at::Tensor* _dropout_state)
+  , *$(at::Tensor* _reserve)
+  , *$(std::array<bool,4>* _output_mask)));
+  }|]
+
+_cudnn_init_dropout_state_out_tdbl
+  :: Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+_cudnn_init_dropout_state_out_tdbl _out _dropout _train _dropout_seed =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cudnn_init_dropout_state_out(
+    *$(at::Tensor* _out)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(int64_t _dropout_seed)));
+  }|]
+
+_fused_dropout_out_tttdG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_dropout_out_tttdG _out0 _out1 _self _p _generator =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_dropout_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+_fused_dropout_out_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_dropout_out_tttd _out0 _out1 _self _p =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_dropout_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+_masked_scale_out_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+_masked_scale_out_tttd _out _self _mask _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_scale_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , $(double _scale)));
+  }|]
+
+native_dropout_out_tttdb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+native_dropout_out_tttdb _out0 _out1 _input _p _train =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::native_dropout_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input)
+  , $(double _p)
+  , $(bool _train)));
+  }|]
+
+native_dropout_backward_out_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+native_dropout_backward_out_tttd _out _grad_output _mask _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_dropout_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _mask)
+  , $(double _scale)));
+  }|]
+
+_conj_physical_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_conj_physical_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_conj_physical_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_add_relu_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu_out_ttss _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_add_relu_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_add_relu_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_add_relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+add_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+add_out_ttss _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::add_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+add_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+add_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::add_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+affine_grid_generator_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+affine_grid_generator_out_ttlb _out _theta _size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::affine_grid_generator_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _theta)
+  , *$(std::vector<int64_t>* _size)
+  , $(bool _align_corners)));
+  }|]
+
+bartlett_window_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+bartlett_window_out_tl _out _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bartlett_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)));
+  }|]
+
+bartlett_window_out_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+bartlett_window_out_tlb _out _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bartlett_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+quantized_batch_norm_out_ttttttddl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+quantized_batch_norm_out_ttttttddl _out _input _weight _bias _mean _var _eps _output_scale _output_zero_point =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_batch_norm_out(
+    *$(at::Tensor* _out)
+  , *$(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)));
+  }|]
+
+bernoulli_out_tttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+bernoulli_out_tttG _out _self _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+bernoulli_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bernoulli_out_ttt _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _p)));
+  }|]
+
+bernoulli_ttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+bernoulli_ttG _self _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+bernoulli_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bernoulli_tt _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _p)));
+  }|]
+
+bernoulli_out_ttdG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+bernoulli_out_ttdG _out _self _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+bernoulli_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+bernoulli_out_ttd _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+-- bernoulli_out_tt
+--   :: Ptr Tensor
+--   -> Ptr Tensor
+--   -> IO (Ptr Tensor)
+-- bernoulli_out_tt _out _self =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::bernoulli_out(
+--     *$(at::Tensor* _out)
+--   , *$(at::Tensor* _self)));
+--   }|]
+
+binary_cross_entropy_with_logits_out_tttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+binary_cross_entropy_with_logits_out_tttttl _out _self _target _weight _pos_weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_with_logits_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _pos_weight)
+  , $(int64_t _reduction)));
+  }|]
+
+binary_cross_entropy_with_logits_out_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_with_logits_out_ttttt _out _self _target _weight _pos_weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_with_logits_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _pos_weight)));
+  }|]
+
+binary_cross_entropy_with_logits_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_with_logits_out_tttt _out _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_with_logits_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+binary_cross_entropy_with_logits_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binary_cross_entropy_with_logits_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binary_cross_entropy_with_logits_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+bincount_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+bincount_out_tttl _out _self _weights _minlength =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bincount_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weights)
+  , $(int64_t _minlength)));
+  }|]
+
+bincount_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bincount_out_ttt _out _self _weights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bincount_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weights)));
+  }|]
+
+bincount_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bincount_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bincount_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+blackman_window_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+blackman_window_out_tl _out _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::blackman_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)));
+  }|]
+
+blackman_window_out_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+blackman_window_out_tlb _out _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::blackman_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+block_diag_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+block_diag_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::block_diag_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+constant_pad_nd_out_ttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+constant_pad_nd_out_ttls _out _self _pad _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::constant_pad_nd_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)
+  , *$(at::Scalar* _value)));
+  }|]
+
+constant_pad_nd_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+constant_pad_nd_out_ttl _out _self _pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::constant_pad_nd_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)));
+  }|]
+
+convolution_out_ttttlllbll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+convolution_out_ttttlllbll _out _input _weight _bias _stride _padding _dilation _transposed _output_padding _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::convolution_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)));
+  }|]
+
+convolution_backward_out_ttttttllllblla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+convolution_backward_out_ttttttllllblla _out0 _out1 _out2 _grad_output _input _weight _bias_sizes _stride _padding _dilation _transposed _output_padding _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::convolution_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _bias_sizes)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+convolution_overrideable_out_ttttlllbll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+convolution_overrideable_out_ttttlllbll _out _input _weight _bias _stride _padding _dilation _transposed _output_padding _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::convolution_overrideable_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)));
+  }|]
+
+convolution_backward_overrideable_out_ttttttlllblla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+convolution_backward_overrideable_out_ttttttlllblla _out0 _out1 _out2 _grad_output _input _weight _stride _padding _dilation _transposed _output_padding _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::convolution_backward_overrideable_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+_convolution_out_ttttlllbllbbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_convolution_out_ttttlllbllbbbb _out _input _weight _bias _stride _padding _dilation _transposed _output_padding _groups _benchmark _deterministic _cudnn_enabled _allow_tf32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convolution_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _transposed)
+  , *$(std::vector<int64_t>* _output_padding)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)
+  , $(bool _cudnn_enabled)
+  , $(bool _allow_tf32)));
+  }|]
+
+conv_tbc_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+conv_tbc_out_ttttl _out _self _weight _bias _pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_tbc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(int64_t _pad)));
+  }|]
+
+conv_tbc_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+conv_tbc_out_tttt _out _self _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_tbc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+copy_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+copy_out_tttb _out _self _src _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(bool _non_blocking)));
+  }|]
+
+copy_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+copy_out_ttt _out _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+_copy_from_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_copy_from_out_tttb _out _self _dst _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_copy_from_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _dst)
+  , $(bool _non_blocking)));
+  }|]
+
+_copy_from_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_copy_from_out_ttt _out _self _dst =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_copy_from_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _dst)));
+  }|]
+
+_copy_from_and_resize_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_copy_from_and_resize_out_ttt _out _self _dst =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_copy_from_and_resize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _dst)));
+  }|]
+
+count_nonzero_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+count_nonzero_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::count_nonzero_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+count_nonzero_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+count_nonzero_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::count_nonzero_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+cudnn_affine_grid_generator_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+cudnn_affine_grid_generator_out_ttllll _out _theta _N _C _H _W =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_affine_grid_generator_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _theta)
+  , $(int64_t _N)
+  , $(int64_t _C)
+  , $(int64_t _H)
+  , $(int64_t _W)));
+  }|]
+
+cudnn_affine_grid_generator_backward_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+cudnn_affine_grid_generator_backward_out_ttllll _out _grad _N _C _H _W =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_affine_grid_generator_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , $(int64_t _N)
+  , $(int64_t _C)
+  , $(int64_t _H)
+  , $(int64_t _W)));
+  }|]
+
+cudnn_batch_norm_out_tttttttttbdd
+  :: Ptr Tensor
+  -> 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,Tensor)))
+cudnn_batch_norm_out_tttttttttbdd _out0 _out1 _out2 _out3 _input _weight _bias _running_mean _running_var _training _exponential_average_factor _epsilon =
+  [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::cudnn_batch_norm_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _exponential_average_factor)
+  , $(double _epsilon)));
+  }|]
+
+cudnn_batch_norm_backward_out_ttttttttttdt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+cudnn_batch_norm_backward_out_ttttttttttdt _out0 _out1 _out2 _input _grad_output _weight _running_mean _running_var _save_mean _save_var _epsilon _reserveSpace =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::cudnn_batch_norm_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_var)
+  , $(double _epsilon)
+  , *$(at::Tensor* _reserveSpace)));
+  }|]
+
+cudnn_convolution_out_tttllllbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+cudnn_convolution_out_tttllllbbb _out _self _weight _padding _stride _dilation _groups _benchmark _deterministic _allow_tf32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_out(
+    *$(at::Tensor* _out)
+  , *$(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)
+  , $(bool _allow_tf32)));
+  }|]
+
+cudnn_convolution_transpose_out_tttlllllbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+cudnn_convolution_transpose_out_tttlllllbbb _out _self _weight _padding _output_padding _stride _dilation _groups _benchmark _deterministic _allow_tf32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_transpose_out(
+    *$(at::Tensor* _out)
+  , *$(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)
+  , $(bool _allow_tf32)));
+  }|]
+
+_mps_convolution_transpose_out_tttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+_mps_convolution_transpose_out_tttlllll _out _self _weight _padding _output_padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mps_convolution_transpose_out(
+    *$(at::Tensor* _out)
+  , *$(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)));
+  }|]
+
+mps_convolution_transpose_backward_out_tttttllllla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mps_convolution_transpose_backward_out_tttttllllla _out0 _out1 _self _grad_output _weight _padding _output_padding _stride _dilation _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mps_convolution_transpose_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_output)
+  , *$(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)
+  , *$(std::array<bool,2>* _output_mask)));
+  }|]
+
+cudnn_convolution_relu_out_ttttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+cudnn_convolution_relu_out_ttttllll _out _self _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+cudnn_convolution_add_relu_out_ttttstllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+cudnn_convolution_add_relu_out_ttttstllll _out _self _weight _z _alpha _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_convolution_add_relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _z)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+cudnn_grid_sampler_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cudnn_grid_sampler_out_ttt _out _self _grid =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cudnn_grid_sampler_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _grid)));
+  }|]
+
+cudnn_grid_sampler_backward_out_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+cudnn_grid_sampler_backward_out_ttttt _out0 _out1 _self _grid _grad_output =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::cudnn_grid_sampler_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _grid)
+  , *$(at::Tensor* _grad_output)));
+  }|]
+
+_ctc_loss_out_ttttlllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttlllb _out0 _out1 _log_probs _targets _input_lengths _target_lengths _blank _zero_infinity =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)
+  , $(bool _zero_infinity)));
+  }|]
+
+_ctc_loss_out_ttttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttlll _out0 _out1 _log_probs _targets _input_lengths _target_lengths _blank =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , $(int64_t _blank)));
+  }|]
+
+_ctc_loss_out_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttll _out0 _out1 _log_probs _targets _input_lengths _target_lengths =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)));
+  }|]
+
+_ctc_loss_out_ttttttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttttlb _out0 _out1 _log_probs _targets _input_lengths _target_lengths _blank _zero_infinity =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)
+  , $(bool _zero_infinity)));
+  }|]
+
+_ctc_loss_out_ttttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_ttttttl _out0 _out1 _log_probs _targets _input_lengths _target_lengths _blank =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)
+  , $(int64_t _blank)));
+  }|]
+
+_ctc_loss_out_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_ctc_loss_out_tttttt _out0 _out1 _log_probs _targets _input_lengths _target_lengths =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_ctc_loss_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(at::Tensor* _input_lengths)
+  , *$(at::Tensor* _target_lengths)));
+  }|]
+
+_ctc_loss_backward_out_ttttllttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_ctc_loss_backward_out_ttttllttlb _out _grad _log_probs _targets _input_lengths _target_lengths _neg_log_likelihood _log_alpha _blank _zero_infinity =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_ctc_loss_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , *$(at::Tensor* _neg_log_likelihood)
+  , *$(at::Tensor* _log_alpha)
+  , $(int64_t _blank)
+  , $(bool _zero_infinity)));
+  }|]
+
+_ctc_loss_backward_out_ttttllttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_ctc_loss_backward_out_ttttllttl _out _grad _log_probs _targets _input_lengths _target_lengths _neg_log_likelihood _log_alpha _blank =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_ctc_loss_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _log_probs)
+  , *$(at::Tensor* _targets)
+  , *$(std::vector<int64_t>* _input_lengths)
+  , *$(std::vector<int64_t>* _target_lengths)
+  , *$(at::Tensor* _neg_log_likelihood)
+  , *$(at::Tensor* _log_alpha)
+  , $(int64_t _blank)));
+  }|]
+
+diag_embed_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diag_embed_out_ttlll _out _self _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_embed_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+diag_embed_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diag_embed_out_ttll _out _self _offset _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_embed_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)));
+  }|]
+
+diag_embed_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diag_embed_out_ttl _out _self _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_embed_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _offset)));
+  }|]
+
+diag_embed_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diag_embed_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_embed_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+diagonal_backward_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_backward_out_ttllll _out _grad_output _input_sizes _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _input_sizes)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+div_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+div_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::div_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+div_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+div_out_ttss _out _self _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::div_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+embedding_out_tttlbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+embedding_out_tttlbb _out _weight _indices _padding_idx _scale_grad_by_freq _sparse =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _padding_idx)
+  , $(bool _scale_grad_by_freq)
+  , $(bool _sparse)));
+  }|]
+
+embedding_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+embedding_out_tttlb _out _weight _indices _padding_idx _scale_grad_by_freq =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _padding_idx)
+  , $(bool _scale_grad_by_freq)));
+  }|]
+
+embedding_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+embedding_out_tttl _out _weight _indices _padding_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _padding_idx)));
+  }|]
+
+embedding_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+embedding_out_ttt _out _weight _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+embedding_dense_backward_out_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+embedding_dense_backward_out_tttllb _out _grad_output _indices _num_weights _padding_idx _scale_grad_by_freq =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_dense_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _num_weights)
+  , $(int64_t _padding_idx)
+  , $(bool _scale_grad_by_freq)));
+  }|]
+
+embedding_renorm_out_tttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+embedding_renorm_out_tttdd _out _self _indices _max_norm _norm_type =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_renorm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , $(double _max_norm)
+  , $(double _norm_type)));
+  }|]
+
+embedding_renorm_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+embedding_renorm_ttdd _self _indices _max_norm _norm_type =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_renorm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , $(double _max_norm)
+  , $(double _norm_type)));
+  }|]
+
+_embedding_bag_forward_only_out_tttttttblbtbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttblbtbl _out0 _out1 _out2 _out3 _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset _padding_idx =
+  [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_forward_only_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(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)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_forward_only_out_tttttttblbtb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttblbtb _out0 _out1 _out2 _out3 _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_forward_only_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(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_forward_only_out_tttttttblbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttblbt _out0 _out1 _out2 _out3 _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_forward_only_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(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_forward_only_out_tttttttblb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttblb _out0 _out1 _out2 _out3 _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_forward_only_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)));
+  }|]
+
+_embedding_bag_forward_only_out_tttttttbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttbl _out0 _out1 _out2 _out3 _weight _indices _offsets _scale_grad_by_freq _mode =
+  [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_forward_only_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)));
+  }|]
+
+_embedding_bag_forward_only_out_tttttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_tttttttb _out0 _out1 _out2 _out3 _weight _indices _offsets _scale_grad_by_freq =
+  [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_forward_only_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)));
+  }|]
+
+_embedding_bag_forward_only_out_ttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_out_ttttttt _out0 _out1 _out2 _out3 _weight _indices _offsets =
+  [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_forward_only_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)));
+  }|]
+
+_embedding_bag_out_tttttttblbtbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttblbtbl _out0 _out1 _out2 _out3 _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset _padding_idx =
+  [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_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(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)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_out_tttttttblbtb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttblbtb _out0 _out1 _out2 _out3 _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_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(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_out_tttttttblbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttblbt _out0 _out1 _out2 _out3 _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_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(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_out_tttttttblb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttblb _out0 _out1 _out2 _out3 _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_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)));
+  }|]
+
+_embedding_bag_out_tttttttbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttbl _out0 _out1 _out2 _out3 _weight _indices _offsets _scale_grad_by_freq _mode =
+  [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_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)));
+  }|]
+
+_embedding_bag_out_tttttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_tttttttb _out0 _out1 _out2 _out3 _weight _indices _offsets _scale_grad_by_freq =
+  [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_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)));
+  }|]
+
+_embedding_bag_out_ttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_out_ttttttt _out0 _out1 _out2 _out3 _weight _indices _offsets =
+  [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_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)));
+  }|]
+
+_embedding_bag_dense_backward_out_ttttttlbltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_embedding_bag_dense_backward_out_ttttttlbltl _out _grad _indices _offset2bag _bag_size _maximum_indices _num_weights _scale_grad_by_freq _mode _per_sample_weights _padding_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_dense_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offset2bag)
+  , *$(at::Tensor* _bag_size)
+  , *$(at::Tensor* _maximum_indices)
+  , $(int64_t _num_weights)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , *$(at::Tensor* _per_sample_weights)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_dense_backward_out_ttttttlblt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_embedding_bag_dense_backward_out_ttttttlblt _out _grad _indices _offset2bag _bag_size _maximum_indices _num_weights _scale_grad_by_freq _mode _per_sample_weights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_dense_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offset2bag)
+  , *$(at::Tensor* _bag_size)
+  , *$(at::Tensor* _maximum_indices)
+  , $(int64_t _num_weights)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , *$(at::Tensor* _per_sample_weights)));
+  }|]
+
+_embedding_bag_per_sample_weights_backward_out_ttttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_embedding_bag_per_sample_weights_backward_out_ttttttll _out _grad _weight _indices _offsets _offset2bag _mode _padding_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_per_sample_weights_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , *$(at::Tensor* _offset2bag)
+  , $(int64_t _mode)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_per_sample_weights_backward_out_ttttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_embedding_bag_per_sample_weights_backward_out_ttttttl _out _grad _weight _indices _offsets _offset2bag _mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_per_sample_weights_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , *$(at::Tensor* _offset2bag)
+  , $(int64_t _mode)));
+  }|]
+
+empty_out_tlNM
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr DimnameList
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_out_tlNM _out _size _names _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_out_tlN
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+empty_out_tlN _out _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+new_empty_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+new_empty_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::new_empty_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+new_empty_strided_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+new_empty_strided_out_ttll _out _self _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::new_empty_strided_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+new_full_out_ttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+new_full_out_ttls _out _self _size _fill_value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::new_full_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)));
+  }|]
+
+new_zeros_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+new_zeros_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::new_zeros_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+new_ones_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+new_ones_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::new_ones_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_empty_affine_quantized_out_tldlM
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> Int64
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_out_tldlM _out _size _scale _zero_point _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , $(double _scale)
+  , $(int64_t _zero_point)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_empty_affine_quantized_out_tldl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_out_tldl _out _size _scale _zero_point =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , $(double _scale)
+  , $(int64_t _zero_point)));
+  }|]
+
+_empty_affine_quantized_out_tld
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CDouble
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_out_tld _out _size _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , $(double _scale)));
+  }|]
+
+_empty_affine_quantized_out_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_out_tl _out _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_empty_per_channel_affine_quantized_out_tlttlM
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_empty_per_channel_affine_quantized_out_tlttlM _out _size _scales _zero_points _axis _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_per_channel_affine_quantized_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_empty_per_channel_affine_quantized_out_tlttl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_empty_per_channel_affine_quantized_out_tlttl _out _size _scales _zero_points _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_per_channel_affine_quantized_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)));
+  }|]
+
+resize_out_ttlM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+resize_out_ttlM _out _self _size _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+resize_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+resize_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+resize_tlM
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+resize_tlM _self _size _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+resize_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+resize_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_resize_output_out_ttlD
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> DeviceType
+  -> IO (Ptr Tensor)
+_resize_output_out_ttlD _out _self _size _device =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_resize_output_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(at::DeviceType _device)));
+  }|]
+
+_resize_output_tlD
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> DeviceType
+  -> IO (Ptr Tensor)
+_resize_output_tlD _self _size _device =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_resize_output(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(at::DeviceType _device)));
+  }|]
+
+empty_quantized_out_tltM
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_quantized_out_tltM _out _size _qtensor _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_quantized_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _qtensor)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_quantized_out_tlt
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+empty_quantized_out_tlt _out _size _qtensor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_quantized_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _qtensor)));
+  }|]
+
+empty_like_out_ttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_like_out_ttM _out _self _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_like_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+empty_like_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+empty_strided_out_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+empty_strided_out_tll _out _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_strided_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+fill_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+fill_out_tts _out _self _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fill_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _value)));
+  }|]
+
+fill_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fill_out_ttt _out _self _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fill_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _value)));
+  }|]
+
+full_out_tlsN
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+full_out_tlsN _out _size _fill_value _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+full_like_out_ttsM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+full_like_out_ttsM _out _self _fill_value _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _fill_value)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+full_like_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+full_like_out_tts _out _self _fill_value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _fill_value)));
+  }|]
+
+from_file_out_tsbl
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+from_file_out_tsbl _out _filename _shared _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::from_file_out(
+    *$(at::Tensor* _out)
+  , *$(std::string* _filename)
+  , $(bool _shared)
+  , $(int64_t _size)));
+  }|]
+
+from_file_out_tsb
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+from_file_out_tsb _out _filename _shared =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::from_file_out(
+    *$(at::Tensor* _out)
+  , *$(std::string* _filename)
+  , $(bool _shared)));
+  }|]
+
+from_file_out_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+from_file_out_ts _out _filename =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::from_file_out(
+    *$(at::Tensor* _out)
+  , *$(std::string* _filename)));
+  }|]
+
+grid_sampler_2d_out_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+grid_sampler_2d_out_tttllb _out _input _grid _interpolation_mode _padding_mode _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::grid_sampler_2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)));
+  }|]
+
+grid_sampler_2d_backward_out_tttttllba
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+grid_sampler_2d_backward_out_tttttllba _out0 _out1 _grad_output _input _grid _interpolation_mode _padding_mode _align_corners _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::grid_sampler_2d_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)
+  , *$(std::array<bool,2>* _output_mask)));
+  }|]
+
+_grid_sampler_2d_cpu_fallback_out_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_grid_sampler_2d_cpu_fallback_out_tttllb _out _input _grid _interpolation_mode _padding_mode _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_grid_sampler_2d_cpu_fallback_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)));
+  }|]
+
+grid_sampler_3d_out_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+grid_sampler_3d_out_tttllb _out _input _grid _interpolation_mode _padding_mode _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::grid_sampler_3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)));
+  }|]
+
+grid_sampler_3d_backward_out_tttttllba
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+grid_sampler_3d_backward_out_tttttllba _out0 _out1 _grad_output _input _grid _interpolation_mode _padding_mode _align_corners _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::grid_sampler_3d_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)
+  , *$(std::array<bool,2>* _output_mask)));
+  }|]
+
+hann_window_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+hann_window_out_tl _out _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hann_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)));
+  }|]
+
+hann_window_out_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+hann_window_out_tlb _out _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hann_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+hamming_window_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+hamming_window_out_tl _out _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)));
+  }|]
+
+hamming_window_out_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+hamming_window_out_tlb _out _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+hamming_window_out_tlbd
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+hamming_window_out_tlbd _out _window_length _periodic _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)));
+  }|]
+
+hamming_window_out_tlbdd
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+hamming_window_out_tlbdd _out _window_length _periodic _alpha _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)
+  , $(double _beta)));
+  }|]
+
+kaiser_window_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+kaiser_window_out_tl _out _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)));
+  }|]
+
+kaiser_window_out_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+kaiser_window_out_tlb _out _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+kaiser_window_out_tlbd
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+kaiser_window_out_tlbd _out _window_length _periodic _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _beta)));
+  }|]
+
+native_group_norm_out_ttttttlllld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_group_norm_out_ttttttlllld _out0 _out1 _out2 _input _weight _bias _N _C _HxW _group _eps =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_group_norm_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(int64_t _N)
+  , $(int64_t _C)
+  , $(int64_t _HxW)
+  , $(int64_t _group)
+  , $(double _eps)));
+  }|]
+
+native_group_norm_backward_out_ttttttttlllla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_group_norm_backward_out_ttttttttlllla _out0 _out1 _out2 _grad_out _input _mean _rstd _weight _N _C _HxW _group _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_group_norm_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _rstd)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _N)
+  , $(int64_t _C)
+  , $(int64_t _HxW)
+  , $(int64_t _group)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+index_put_out_ttltb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+index_put_out_ttltb _out _self _indices _values _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_put_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)));
+  }|]
+
+index_put_out_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_put_out_ttlt _out _self _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_put_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+_index_put_impl_out_ttltbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_index_put_impl_out_ttltbb _out _self _indices _values _accumulate _unsafe =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)
+  , $(bool _unsafe)));
+  }|]
+
+_index_put_impl_out_ttltb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_index_put_impl_out_ttltb _out _self _indices _values _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)));
+  }|]
+
+_index_put_impl_out_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_index_put_impl_out_ttlt _out _self _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+_index_put_impl_tltbb
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_index_put_impl_tltbb _self _indices _values _accumulate _unsafe =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)
+  , $(bool _unsafe)));
+  }|]
+
+_index_put_impl_tltb
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_index_put_impl_tltb _self _indices _values _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)));
+  }|]
+
+_index_put_impl_tlt
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_index_put_impl_tlt _self _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+isnan_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isnan_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isnan_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+native_layer_norm_out_ttttlttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_layer_norm_out_ttttlttd _out0 _out1 _out2 _input _normalized_shape _weight _bias _eps =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_layer_norm_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(double _eps)));
+  }|]
+
+native_layer_norm_backward_out_tttttltttta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_layer_norm_backward_out_tttttltttta _out0 _out1 _out2 _grad_out _input _normalized_shape _mean _rstd _weight _bias _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_layer_norm_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _rstd)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+linear_backward_out_tttttta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linear_backward_out_tttttta _out0 _out1 _out2 _self _grad_output _weight _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linear_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+mkldnn_linear_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_linear_out_tttt _out _self _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_linear_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+mkldnn_linear_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_linear_out_ttt _out _self _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_linear_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+mkldnn_linear_backward_input_out_tltt
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_linear_backward_input_out_tltt _out _input_size _grad_output _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_linear_backward_input_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _input_size)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+mkldnn_linear_backward_weights_out_tttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mkldnn_linear_backward_weights_out_tttttb _out0 _out1 _grad_output _input _weight _bias_defined =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mkldnn_linear_backward_weights_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , $(bool _bias_defined)));
+  }|]
+
+mkldnn_linear_backward_out_tttttta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+mkldnn_linear_backward_out_tttttta _out0 _out1 _out2 _self _grad_output _weight _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::mkldnn_linear_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+matmul_backward_out_ttttta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+matmul_backward_out_ttttta _out0 _out1 _grad _self _other _mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::matmul_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::array<bool,2>* _mask)));
+  }|]
+
+_aminmax_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_aminmax_out_ttt _out0 _out1 _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_aminmax_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_aminmax_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_aminmax_out_tttlb _out0 _out1 _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_aminmax_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+_aminmax_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_aminmax_out_tttl _out0 _out1 _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_aminmax_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+max_pool2d_backward_out_tttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+max_pool2d_backward_out_tttllllb _out _grad_output _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool2d_backward_out_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_backward_out_tttllll _out _grad_output _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool2d_backward_out_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_backward_out_tttlll _out _grad_output _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool2d_backward_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_backward_out_tttll _out _grad_output _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool2d_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_backward_out_tttl _out _grad_output _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mkldnn_max_pool2d_out_ttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_out_ttllllb _out _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+mkldnn_max_pool2d_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_out_ttllll _out _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_max_pool2d_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_out_ttlll _out _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_max_pool2d_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_out_ttll _out _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_max_pool2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_out_ttl _out _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mkldnn_max_pool2d_backward_out_ttttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_out_ttttllllb _out _grad_output _output _input _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+mkldnn_max_pool2d_backward_out_ttttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_out_ttttllll _out _grad_output _output _input _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_max_pool2d_backward_out_ttttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_out_ttttlll _out _grad_output _output _input _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_max_pool2d_backward_out_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_out_ttttll _out _grad_output _output _input _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_max_pool2d_backward_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_out_ttttl _out _grad_output _output _input _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mkldnn_max_pool3d_out_ttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_out_ttllllb _out _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+mkldnn_max_pool3d_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_out_ttllll _out _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_max_pool3d_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_out_ttlll _out _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_max_pool3d_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_out_ttll _out _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_max_pool3d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_out_ttl _out _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mkldnn_max_pool3d_backward_out_ttttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_out_ttttllllb _out _grad_output _output _input _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+mkldnn_max_pool3d_backward_out_ttttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_out_ttttllll _out _grad_output _output _input _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_max_pool3d_backward_out_ttttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_out_ttttlll _out _grad_output _output _input _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_max_pool3d_backward_out_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_out_ttttll _out _grad_output _output _input _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_max_pool3d_backward_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_out_ttttl _out _grad_output _output _input _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+quantized_max_pool1d_out_ttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_out_ttllllb _out _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+quantized_max_pool1d_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_out_ttllll _out _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+quantized_max_pool1d_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_out_ttlll _out _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+quantized_max_pool1d_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_out_ttll _out _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+quantized_max_pool1d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_out_ttl _out _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+quantized_max_pool2d_out_ttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_out_ttllllb _out _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+quantized_max_pool2d_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_out_ttllll _out _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+quantized_max_pool2d_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_out_ttlll _out _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+quantized_max_pool2d_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_out_ttll _out _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+quantized_max_pool2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_out_ttl _out _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+median_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+median_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::median_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+nanmedian_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nanmedian_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmedian_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_mps_convolution_out_ttttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+_mps_convolution_out_ttttllll _out _self _weight _bias _padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mps_convolution_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+mps_convolution_backward_out_ttttttlllla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+mps_convolution_backward_out_ttttttlllla _out0 _out1 _out2 _self _grad_output _weight _padding _stride _dilation _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::mps_convolution_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+mkldnn_convolution_out_ttttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+mkldnn_convolution_out_ttttllll _out _self _weight _bias _padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_convolution_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+mkldnn_rnn_layer_out_tttttttttttbllllbbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+mkldnn_rnn_layer_out_tttttttttttbllllbbbb _out0 _out1 _out2 _out3 _input _weight0 _weight1 _weight2 _weight3 _hx_ _cx_ _reverse _batch_sizes _mode _hidden_size _num_layers _has_biases _bidirectional _batch_first _train =
+  [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::mkldnn_rnn_layer_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight0)
+  , *$(at::Tensor* _weight1)
+  , *$(at::Tensor* _weight2)
+  , *$(at::Tensor* _weight3)
+  , *$(at::Tensor* _hx_)
+  , *$(at::Tensor* _cx_)
+  , $(bool _reverse)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _num_layers)
+  , $(bool _has_biases)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)
+  , $(bool _train)));
+  }|]
+
+mkldnn_rnn_layer_backward_out_ttttttttttttttttttttblllbbblbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+mkldnn_rnn_layer_backward_out_ttttttttttttttttttttblllbbblbt _out0 _out1 _out2 _out3 _out4 _out5 _out6 _input _weight1 _weight2 _weight3 _weight4 _hx_ _cx_tmp _output _hy_ _cy_ _grad_output _grad_hy _grad_cy _reverse _mode _hidden_size _num_layers _has_biases _train _bidirectional _batch_sizes _batch_first _workspace =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::mkldnn_rnn_layer_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _out4)
+  , *$(at::Tensor* _out5)
+  , *$(at::Tensor* _out6)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight1)
+  , *$(at::Tensor* _weight2)
+  , *$(at::Tensor* _weight3)
+  , *$(at::Tensor* _weight4)
+  , *$(at::Tensor* _hx_)
+  , *$(at::Tensor* _cx_tmp)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _hy_)
+  , *$(at::Tensor* _cy_)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , $(bool _reverse)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _num_layers)
+  , $(bool _has_biases)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , $(bool _batch_first)
+  , *$(at::Tensor* _workspace)));
+  }|]
+
+miopen_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)))
+miopen_batch_norm_out_ttttttttbdd _out0 _out1 _out2 _input _weight _bias _running_mean _running_var _training _exponential_average_factor _epsilon =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::miopen_batch_norm_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _exponential_average_factor)
+  , $(double _epsilon)));
+  }|]
+
+miopen_batch_norm_backward_out_ttttttttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+miopen_batch_norm_backward_out_ttttttttttd _out0 _out1 _out2 _input _grad_output _weight _running_mean _running_var _save_mean _save_var _epsilon =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::miopen_batch_norm_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_var)
+  , $(double _epsilon)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native14.hs b/src/Torch/Internal/Unmanaged/Native/Native14.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native14.hs
@@ -0,0 +1,4256 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native14 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+miopen_convolution_out_ttttllllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+miopen_convolution_out_ttttllllbb _out _self _weight _bias _padding _stride _dilation _groups _benchmark _deterministic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_convolution_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)));
+  }|]
+
+miopen_convolution_transpose_out_ttttlllllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+miopen_convolution_transpose_out_ttttlllllbb _out _self _weight _bias _padding _output_padding _stride _dilation _groups _benchmark _deterministic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_convolution_transpose_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(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)));
+  }|]
+
+miopen_depthwise_convolution_out_ttttllllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+miopen_depthwise_convolution_out_ttttllllbb _out _self _weight _bias _padding _stride _dilation _groups _benchmark _deterministic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_depthwise_convolution_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)));
+  }|]
+
+miopen_rnn_out_ttttttllttlllbdbblt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+miopen_rnn_out_ttttttllttlllbdbblt _out0 _out1 _out2 _out3 _out4 _input _weight _weight_stride0 _hx _cx _mode _hidden_size _num_layers _batch_first _dropout _train _bidirectional _batch_sizes _dropout_state =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::miopen_rnn_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _out4)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _weight)
+  , $(int64_t _weight_stride0)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _cx)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , *$(at::Tensor* _dropout_state)));
+  }|]
+
+miopen_rnn_backward_out_tttltlltttttttlllbdbbltta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,4))
+  -> IO (())
+miopen_rnn_backward_out_tttltlltttttttlllbdbbltta _out0 _out1 _out2 _out3 _input _weight _weight_stride0 _weight_buf _hx _cx _output _grad_output _grad_hy _grad_cy _mode _hidden_size _num_layers _batch_first _dropout _train _bidirectional _batch_sizes _dropout_state _reserve _output_mask =
+  [C.throwBlock| void {  (at::miopen_rnn_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(std::vector<at::Tensor>* _out3)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _weight)
+  , $(int64_t _weight_stride0)
+  , *$(at::Tensor* _weight_buf)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , *$(at::Tensor* _dropout_state)
+  , *$(at::Tensor* _reserve)
+  , *$(std::array<bool,4>* _output_mask)));
+  }|]
+
+_sparse_sparse_matmul_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_sparse_matmul_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sparse_matmul_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+mul_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+mul_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mul_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+_native_batch_norm_legit_functional_tttttbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_native_batch_norm_legit_functional_tttttbdd _input _weight _bias _running_mean _running_var _training _momentum _eps =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_native_batch_norm_legit_functional(
+    *$(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_out_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+batch_norm_stats_out_tttd _out0 _out1 _input _eps =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_stats_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input)
+  , $(double _eps)));
+  }|]
+
+batch_norm_gather_stats_out_tttttttddl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+batch_norm_gather_stats_out_tttttttddl _out0 _out1 _input _mean _invstd _running_mean _running_var _momentum _eps _count =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_gather_stats_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(double _momentum)
+  , $(double _eps)
+  , $(int64_t _count)));
+  }|]
+
+batch_norm_gather_stats_with_counts_out_tttttttddt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+batch_norm_gather_stats_with_counts_out_tttttttddt _out0 _out1 _input _mean _invstd _running_mean _running_var _momentum _eps _counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_gather_stats_with_counts_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(double _momentum)
+  , $(double _eps)
+  , *$(at::Tensor* _counts)));
+  }|]
+
+native_batch_norm_backward_out_ttttttttttbda
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_batch_norm_backward_out_ttttttttttbda _out0 _out1 _out2 _grad_out _input _weight _running_mean _running_var _save_mean _save_invstd _train _eps _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_batch_norm_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_invstd)
+  , $(bool _train)
+  , $(double _eps)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+batch_norm_backward_reduce_out_tttttttttbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+batch_norm_backward_reduce_out_tttttttttbbb _out0 _out1 _out2 _out3 _grad_out _input _mean _invstd _weight _input_g _weight_g _bias_g =
+  [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::batch_norm_backward_reduce_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , *$(at::Tensor* _weight)
+  , $(bool _input_g)
+  , $(bool _weight_g)
+  , $(bool _bias_g)));
+  }|]
+
+batch_norm_backward_elemt_out_ttttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+batch_norm_backward_elemt_out_ttttttttt _out _grad_out _input _mean _invstd _weight _mean_dy _mean_dy_xmu _count =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::batch_norm_backward_elemt_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _mean_dy)
+  , *$(at::Tensor* _mean_dy_xmu)
+  , *$(at::Tensor* _count)));
+  }|]
+
+batch_norm_update_stats_out_tttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+batch_norm_update_stats_out_tttttd _out0 _out1 _input _running_mean _running_var _momentum =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_update_stats_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(double _momentum)));
+  }|]
+
+_nnpack_spatial_convolution_out_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_nnpack_spatial_convolution_out_ttttll _out _input _weight _bias _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nnpack_spatial_convolution_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+_nnpack_spatial_convolution_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_nnpack_spatial_convolution_out_ttttl _out _input _weight _bias _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nnpack_spatial_convolution_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+ones_out_tlN
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+ones_out_tlN _out _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+ones_like_out_ttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+ones_like_out_ttM _out _self _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+ones_like_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ones_like_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_euclidean_dist_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_euclidean_dist_out_ttt _out _x1 _x2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_euclidean_dist_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)));
+  }|]
+
+_cdist_forward_out_tttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_cdist_forward_out_tttdl _out _x1 _x2 _p _compute_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cdist_forward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)
+  , $(int64_t _compute_mode)));
+  }|]
+
+_cdist_backward_out_ttttdt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_cdist_backward_out_ttttdt _out _grad _x1 _x2 _p _cdist =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cdist_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)
+  , *$(at::Tensor* _cdist)));
+  }|]
+
+_pdist_forward_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+_pdist_forward_out_ttd _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pdist_forward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+_pdist_forward_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_pdist_forward_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pdist_forward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_pdist_backward_out_tttdt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_pdist_backward_out_tttdt _out _grad _self _p _pdist =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pdist_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , $(double _p)
+  , *$(at::Tensor* _pdist)));
+  }|]
+
+pixel_shuffle_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+pixel_shuffle_out_ttl _out _self _upscale_factor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pixel_shuffle_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _upscale_factor)));
+  }|]
+
+pixel_unshuffle_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+pixel_unshuffle_out_ttl _out _self _downscale_factor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pixel_unshuffle_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _downscale_factor)));
+  }|]
+
+channel_shuffle_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+channel_shuffle_out_ttl _out _self _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::channel_shuffle_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _groups)));
+  }|]
+
+_pin_memory_out_ttD
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> DeviceType
+  -> IO (Ptr Tensor)
+_pin_memory_out_ttD _out _self _device =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pin_memory_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::DeviceType _device)));
+  }|]
+
+_pin_memory_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_pin_memory_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pin_memory_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+scalar_tensor_out_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+scalar_tensor_out_ts _out _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scalar_tensor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _s)));
+  }|]
+
+rand_out_tlN
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+rand_out_tlN _out _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+rand_out_tlGN
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+rand_out_tlGN _out _size _generator _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+rand_like_out_ttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+rand_like_out_ttM _out _self _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+rand_like_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rand_like_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+randint_like_out_ttlM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+randint_like_out_ttlM _out _self _high _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _high)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+randint_like_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+randint_like_out_ttl _out _self _high =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _high)));
+  }|]
+
+randint_like_out_ttllM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+randint_like_out_ttllM _out _self _low _high _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _low)
+  , $(int64_t _high)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+randint_like_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+randint_like_out_ttll _out _self _low _high =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _low)
+  , $(int64_t _high)));
+  }|]
+
+randn_out_tlN
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+randn_out_tlN _out _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+randn_out_tlGN
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+randn_out_tlGN _out _size _generator _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+randn_like_out_ttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+randn_like_out_ttM _out _self _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+randn_like_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+randn_like_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+repeat_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+repeat_out_ttl _out _self _repeats =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _repeats)));
+  }|]
+
+repeat_interleave_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+repeat_interleave_out_ttl _out _repeats _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _repeats)
+  , $(int64_t _output_size)));
+  }|]
+
+repeat_interleave_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+repeat_interleave_out_tt _out _repeats =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _repeats)));
+  }|]
+
+_mkldnn_reshape_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_mkldnn_reshape_out_ttl _out _self _shape =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mkldnn_reshape_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _shape)));
+  }|]
+
+relu_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+relu_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+select_backward_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+select_backward_out_ttlll _out _grad_output _input_sizes _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _input_sizes)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+celu_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+celu_out_tts _out _self _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::celu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+celu_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+celu_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::celu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+slice_backward_out_ttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_backward_out_ttlllll _out _grad_output _input_sizes _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _input_sizes)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+slice_scatter_out_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_scatter_out_tttllll _out _self _src _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+slice_scatter_out_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_scatter_out_tttlll _out _self _src _dim _start _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)));
+  }|]
+
+slice_scatter_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_scatter_out_tttll _out _self _src _dim _start =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _start)));
+  }|]
+
+slice_scatter_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_scatter_out_tttl _out _self _src _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)));
+  }|]
+
+slice_scatter_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slice_scatter_out_ttt _out _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+select_scatter_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+select_scatter_out_tttll _out _self _src _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+diagonal_scatter_out_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_scatter_out_tttlll _out _self _src _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+diagonal_scatter_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_scatter_out_tttll _out _self _src _offset _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)));
+  }|]
+
+diagonal_scatter_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_scatter_out_tttl _out _self _src _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _offset)));
+  }|]
+
+diagonal_scatter_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diagonal_scatter_out_ttt _out _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+as_strided_scatter_out_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+as_strided_scatter_out_tttlll _out _self _src _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+as_strided_scatter_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+as_strided_scatter_out_tttll _out _self _src _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+unsafe_split_out_ltll
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (())
+unsafe_split_out_ltll _out _self _split_size _dim =
+  [C.throwBlock| void {  (at::unsafe_split_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _split_size)
+  , $(int64_t _dim)));
+  }|]
+
+unsafe_split_out_ltl
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Int64
+  -> IO (())
+unsafe_split_out_ltl _out _self _split_size =
+  [C.throwBlock| void {  (at::unsafe_split_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _split_size)));
+  }|]
+
+unsafe_split_with_sizes_out_ltll
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (())
+unsafe_split_with_sizes_out_ltll _out _self _split_sizes _dim =
+  [C.throwBlock| void {  (at::unsafe_split_with_sizes_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)
+  , $(int64_t _dim)));
+  }|]
+
+unsafe_split_with_sizes_out_ltl
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+unsafe_split_with_sizes_out_ltl _out _self _split_sizes =
+  [C.throwBlock| void {  (at::unsafe_split_with_sizes_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)));
+  }|]
+
+sum_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+sum_out_tts _out _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+sum_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sum_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+std_mean_out_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_out_tttllb _out0 _out1 _self _dim _correction _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+std_mean_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_out_tttll _out0 _out1 _self _dim _correction =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+std_mean_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_out_tttl _out0 _out1 _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+std_mean_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_out_ttt _out0 _out1 _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)));
+  }|]
+
+prod_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+prod_out_tts _out _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+prod_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+prod_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_mkldnn_transpose_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_mkldnn_transpose_out_ttll _out _self _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mkldnn_transpose_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+flip_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+flip_out_ttl _out _self _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flip_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+roll_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+roll_out_ttll _out _self _shifts _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::roll_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _shifts)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+roll_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+roll_out_ttl _out _self _shifts =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::roll_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _shifts)));
+  }|]
+
+rot90_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+rot90_out_ttll _out _self _k _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rot90_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+rot90_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+rot90_out_ttl _out _self _k =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rot90_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)));
+  }|]
+
+rot90_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rot90_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rot90_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_transform_bias_rescale_qkv_out_tttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_transform_bias_rescale_qkv_out_tttttl _out0 _out1 _out2 _qkv _qkv_bias _num_heads =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_transform_bias_rescale_qkv_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _qkv)
+  , *$(at::Tensor* _qkv_bias)
+  , $(int64_t _num_heads)));
+  }|]
+
+_nested_tensor_from_mask_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_nested_tensor_from_mask_out_tttb _out _t _mask _mask_check =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_mask_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _t)
+  , *$(at::Tensor* _mask)
+  , $(bool _mask_check)));
+  }|]
+
+_nested_tensor_from_mask_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_tensor_from_mask_out_ttt _out _t _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_mask_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _t)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_nested_from_padded_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_nested_from_padded_out_tttb _out _padded _cpu_nested_shape_example _fuse_transform_0213 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _padded)
+  , *$(at::Tensor* _cpu_nested_shape_example)
+  , $(bool _fuse_transform_0213)));
+  }|]
+
+_nested_from_padded_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_from_padded_out_ttt _out _padded _cpu_nested_shape_example =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _padded)
+  , *$(at::Tensor* _cpu_nested_shape_example)));
+  }|]
+
+_nested_tensor_size_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_tensor_size_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_size_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_nested_tensor_strides_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_tensor_strides_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_strides_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_nested_from_padded_and_nested_example_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_from_padded_and_nested_example_out_ttt _out _padded _nt_example =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded_and_nested_example_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _padded)
+  , *$(at::Tensor* _nt_example)));
+  }|]
+
+_trilinear_out_ttttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+_trilinear_out_ttttlllll _out _i1 _i2 _i3 _expand1 _expand2 _expand3 _sumdim _unroll_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_trilinear_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _i1)
+  , *$(at::Tensor* _i2)
+  , *$(at::Tensor* _i3)
+  , *$(std::vector<int64_t>* _expand1)
+  , *$(std::vector<int64_t>* _expand2)
+  , *$(std::vector<int64_t>* _expand3)
+  , *$(std::vector<int64_t>* _sumdim)
+  , $(int64_t _unroll_dim)));
+  }|]
+
+_trilinear_out_ttttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_trilinear_out_ttttllll _out _i1 _i2 _i3 _expand1 _expand2 _expand3 _sumdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_trilinear_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _i1)
+  , *$(at::Tensor* _i2)
+  , *$(at::Tensor* _i3)
+  , *$(std::vector<int64_t>* _expand1)
+  , *$(std::vector<int64_t>* _expand2)
+  , *$(std::vector<int64_t>* _expand3)
+  , *$(std::vector<int64_t>* _sumdim)));
+  }|]
+
+_unique_out_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_unique_out_tttbb _out0 _out1 _self _sorted _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_unique_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , $(bool _sorted)
+  , $(bool _return_inverse)));
+  }|]
+
+_unique_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_unique_out_tttb _out0 _out1 _self _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_unique_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , $(bool _sorted)));
+  }|]
+
+_unique_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_unique_out_ttt _out0 _out1 _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_unique_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)));
+  }|]
+
+unique_dim_out_ttttlbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_out_ttttlbbb _out0 _out1 _out2 _self _dim _sorted _return_inverse _return_counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _sorted)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)));
+  }|]
+
+unique_dim_out_ttttlbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_out_ttttlbb _out0 _out1 _out2 _self _dim _sorted _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _sorted)
+  , $(bool _return_inverse)));
+  }|]
+
+unique_dim_out_ttttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_out_ttttlb _out0 _out1 _out2 _self _dim _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _sorted)));
+  }|]
+
+unique_dim_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_out_ttttl _out0 _out1 _out2 _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+unique_consecutive_out_ttttbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_out_ttttbbl _out0 _out1 _out2 _self _return_inverse _return_counts _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)
+  , $(int64_t _dim)));
+  }|]
+
+unique_consecutive_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_out_ttttbb _out0 _out1 _out2 _self _return_inverse _return_counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)));
+  }|]
+
+unique_consecutive_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_out_ttttb _out0 _out1 _out2 _self _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(bool _return_inverse)));
+  }|]
+
+unique_consecutive_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_out_tttt _out0 _out1 _out2 _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)));
+  }|]
+
+unique_dim_consecutive_out_ttttlbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_out_ttttlbb _out0 _out1 _out2 _self _dim _return_inverse _return_counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_consecutive_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)));
+  }|]
+
+unique_dim_consecutive_out_ttttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_out_ttttlb _out0 _out1 _out2 _self _dim _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_consecutive_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _return_inverse)));
+  }|]
+
+unique_dim_consecutive_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_out_ttttl _out0 _out1 _out2 _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_consecutive_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+_unique2_out_ttttbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_out_ttttbbb _out0 _out1 _out2 _self _sorted _return_inverse _return_counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(bool _sorted)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)));
+  }|]
+
+_unique2_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_out_ttttbb _out0 _out1 _out2 _self _sorted _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(bool _sorted)
+  , $(bool _return_inverse)));
+  }|]
+
+_unique2_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_out_ttttb _out0 _out1 _out2 _self _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)
+  , $(bool _sorted)));
+  }|]
+
+_unique2_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_out_tttt _out0 _out1 _out2 _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_unsafe_view_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_unsafe_view_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_unsafe_view_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+var_mean_out_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_out_tttllb _out0 _out1 _self _dim _correction _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+var_mean_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_out_tttll _out0 _out1 _self _dim _correction =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+var_mean_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_out_tttl _out0 _out1 _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+var_mean_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_out_ttt _out0 _out1 _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_weight_norm_interface_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_out_ttttl _out0 _out1 _v _g _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_interface_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _v)
+  , *$(at::Tensor* _g)
+  , $(int64_t _dim)));
+  }|]
+
+_weight_norm_interface_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_out_tttt _out0 _out1 _v _g =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_interface_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _v)
+  , *$(at::Tensor* _g)));
+  }|]
+
+_weight_norm_interface_backward_out_ttttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_backward_out_ttttttl _out0 _out1 _grad_w _saved_v _saved_g _saved_norms _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_interface_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _grad_w)
+  , *$(at::Tensor* _saved_v)
+  , *$(at::Tensor* _saved_g)
+  , *$(at::Tensor* _saved_norms)
+  , $(int64_t _dim)));
+  }|]
+
+zeros_out_tlN
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+zeros_out_tlN _out _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+_efficientzerotensor_out_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_efficientzerotensor_out_tl _out _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_efficientzerotensor_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+zeros_like_out_ttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+zeros_like_out_ttM _out _self _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+zeros_like_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+zeros_like_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_like_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_standard_gamma_grad_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_standard_gamma_grad_out_ttt _out _self _output =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_standard_gamma_grad_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _output)));
+  }|]
+
+_standard_gamma_out_ttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+_standard_gamma_out_ttG _out _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_standard_gamma_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+_standard_gamma_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_standard_gamma_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_standard_gamma_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_dirichlet_grad_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_dirichlet_grad_out_tttt _out _x _alpha _total =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_dirichlet_grad_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _alpha)
+  , *$(at::Tensor* _total)));
+  }|]
+
+_sample_dirichlet_out_ttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+_sample_dirichlet_out_ttG _out _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sample_dirichlet_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+_sample_dirichlet_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sample_dirichlet_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sample_dirichlet_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+poisson_out_ttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+poisson_out_ttG _out _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::poisson_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+poisson_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+poisson_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::poisson_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+binomial_out_tttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+binomial_out_tttG _out _count _prob _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binomial_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _count)
+  , *$(at::Tensor* _prob)
+  , *$(at::Generator* _generator)));
+  }|]
+
+binomial_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binomial_out_ttt _out _count _prob =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binomial_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _count)
+  , *$(at::Tensor* _prob)));
+  }|]
+
+native_norm_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+native_norm_out_tts _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)));
+  }|]
+
+native_norm_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+native_norm_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+native_norm_out_ttslbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+native_norm_out_ttslbs _out _self _p _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_sum_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_sum_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+_sparse_sum_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_sum_backward_out_tttl _out _grad _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sum_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+_sparse_csr_sum_out_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_csr_sum_out_ttlbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_csr_sum_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_sparse_csr_sum_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+_sparse_csr_sum_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_csr_sum_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+_sparse_csr_prod_out_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_csr_prod_out_ttlbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_csr_prod_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_sparse_csr_prod_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+_sparse_csr_prod_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_csr_prod_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+_sparse_softmax_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_sparse_softmax_out_ttlb _out _self _dim _half_to_float =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _half_to_float)));
+  }|]
+
+_sparse_softmax_backward_data_out_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_softmax_backward_data_out_tttlt _out _grad_output _output _dim _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_softmax_backward_data_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_sparse_log_softmax_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_sparse_log_softmax_out_ttlb _out _self _dim _half_to_float =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_log_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _half_to_float)));
+  }|]
+
+_sparse_log_softmax_backward_data_out_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_log_softmax_backward_data_out_tttlt _out _grad_output _output _dim _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_log_softmax_backward_data_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_spdiags_out_tttlL
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Layout
+  -> IO (Ptr Tensor)
+_spdiags_out_tttlL _out _diagonals _offsets _shape _layout =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_spdiags_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _diagonals)
+  , *$(at::Tensor* _offsets)
+  , *$(std::vector<int64_t>* _shape)
+  , $(at::Layout _layout)));
+  }|]
+
+_spdiags_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_spdiags_out_tttl _out _diagonals _offsets _shape =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_spdiags_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _diagonals)
+  , *$(at::Tensor* _offsets)
+  , *$(std::vector<int64_t>* _shape)));
+  }|]
+
+norm_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> ScalarType
+  -> IO (Ptr Tensor)
+norm_out_ttss _out _self _p _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+norm_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+norm_out_tts _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)));
+  }|]
+
+norm_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+norm_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+clone_out_ttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+clone_out_ttM _out _self _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clone_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+clone_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+clone_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clone_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+resize_as_out_tttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+resize_as_out_tttM _out _self _the_template _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+resize_as_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+resize_as_out_ttt _out _self _the_template =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)));
+  }|]
+
+resize_as_ttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+resize_as_ttM _self _the_template _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+resize_as_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+resize_as_tt _self _the_template =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)));
+  }|]
+
+resize_as_sparse_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+resize_as_sparse_out_ttt _out _self _the_template =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as_sparse_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)));
+  }|]
+
+resize_as_sparse_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+resize_as_sparse_tt _self _the_template =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as_sparse(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)));
+  }|]
+
+zero_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+zero_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zero_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+zero_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+zero_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zero(
+    *$(at::Tensor* _self)));
+  }|]
+
+sub_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sub_out_ttss _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sub_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+sub_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sub_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sub_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+rsub_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rsub_out_ttts _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsub_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+rsub_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rsub_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsub_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+rsub_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rsub_out_ttss _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsub_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+rsub_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rsub_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsub_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+_sparse_addmm_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_sparse_addmm_out_ttttss _out _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_sparse_addmm_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_sparse_addmm_out_tttts _out _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+_sparse_addmm_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_addmm_out_tttt _out _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+sparse_coo_tensor_out_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_out_tl _out _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_coo_tensor_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_coo_tensor_with_dims_out_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_with_dims_out_tlll _out _sparse_dim _dense_dim _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_coo_tensor_with_dims_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_coo_tensor_with_dims_and_tensors_out_tllltt
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_with_dims_and_tensors_out_tllltt _out _sparse_dim _dense_dim _size _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_coo_tensor_with_dims_and_tensors_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+sparse_resize_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+sparse_resize_out_ttlll _out _self _size _sparse_dim _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_resize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)));
+  }|]
+
+sparse_resize_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+sparse_resize_tlll _self _size _sparse_dim _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_resize(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)));
+  }|]
+
+sparse_resize_and_clear_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+sparse_resize_and_clear_out_ttlll _out _self _size _sparse_dim _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_resize_and_clear_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)));
+  }|]
+
+sparse_resize_and_clear_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+sparse_resize_and_clear_tlll _self _size _sparse_dim _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_resize_and_clear(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)));
+  }|]
+
+sparse_mask_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sparse_mask_out_ttt _out _self _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_mask_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_to_dense_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_to_dense_out_tts _out _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_dense_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_to_dense_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_to_dense_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_dense_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_coalesce_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_coalesce_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_coalesce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_coalesced_out_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_coalesced_out_ttb _out _self _coalesced =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_coalesced_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _coalesced)));
+  }|]
+
+_coalesced_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_coalesced_tb _self _coalesced =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_coalesced(
+    *$(at::Tensor* _self)
+  , $(bool _coalesced)));
+  }|]
+
+copy_sparse_to_sparse_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+copy_sparse_to_sparse_out_tttb _out _self _src _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_sparse_to_sparse_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(bool _non_blocking)));
+  }|]
+
+copy_sparse_to_sparse_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+copy_sparse_to_sparse_out_ttt _out _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_sparse_to_sparse_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+copy_sparse_to_sparse_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+copy_sparse_to_sparse_ttb _self _src _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_sparse_to_sparse(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(bool _non_blocking)));
+  }|]
+
+copy_sparse_to_sparse_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+copy_sparse_to_sparse_tt _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_sparse_to_sparse(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+to_mkldnn_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+to_mkldnn_out_tts _out _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::to_mkldnn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+to_mkldnn_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+to_mkldnn_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::to_mkldnn_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_out_ttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttlllll _out _self _padding _stride _dilation _groups _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttllll _out _self _padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttlll _out _self _padding _stride _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttll _out _self _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_out_ttl _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_out_ttllll _out _self _padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_out_ttlll _out _self _padding _stride _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_out_ttll _out _self _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_out_ttl _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+quantize_per_tensor_dynamic_out_ttsb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> CBool
+  -> IO (Ptr Tensor)
+quantize_per_tensor_dynamic_out_ttsb _out _self _dtype _reduce_range =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor_dynamic_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)
+  , $(bool _reduce_range)));
+  }|]
+
+quantize_per_tensor_out_ttdls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+quantize_per_tensor_out_ttdls _out _self _scale _zero_point _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _scale)
+  , $(int64_t _zero_point)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+quantize_per_tensor_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+quantize_per_tensor_out_tttts _out _self _scale _zero_point _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+quantize_per_tensor_out_lltts
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (())
+quantize_per_tensor_out_lltts _out _tensors _scales _zero_points _dtype =
+  [C.throwBlock| void {  (at::quantize_per_tensor_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+quantize_per_channel_out_ttttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+quantize_per_channel_out_ttttls _out _self _scales _zero_points _axis _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_channel_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+dequantize_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+dequantize_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dequantize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+dequantize_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+dequantize_out_ll _out _tensors =
+  [C.throwBlock| void {  (at::dequantize_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+q_per_channel_scales_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+q_per_channel_scales_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::q_per_channel_scales_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+q_per_channel_zero_points_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+q_per_channel_zero_points_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::q_per_channel_zero_points_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+int_repr_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+int_repr_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::int_repr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_make_per_tensor_quantized_tensor_out_ttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_make_per_tensor_quantized_tensor_out_ttdl _out _self _scale _zero_point =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_per_tensor_quantized_tensor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _scale)
+  , $(int64_t _zero_point)));
+  }|]
+
+_make_per_channel_quantized_tensor_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_make_per_channel_quantized_tensor_out_ttttl _out _self _scale _zero_point _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_per_channel_quantized_tensor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)));
+  }|]
+
+fake_quantize_per_tensor_affine_cachemask_out_tttdlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+fake_quantize_per_tensor_affine_cachemask_out_tttdlll _out0 _out1 _self _scale _zero_point _quant_min _quant_max =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fake_quantize_per_tensor_affine_cachemask_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , $(double _scale)
+  , $(int64_t _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out_ttttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out_ttttttll _out0 _out1 _self _scale _zero_point _fake_quant_enabled _quant_min _quant_max =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , *$(at::Tensor* _fake_quant_enabled)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+_fake_quantize_learnable_per_tensor_affine_out_ttttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+_fake_quantize_learnable_per_tensor_affine_out_ttttlld _out _self _scale _zero_point _quant_min _quant_max _grad_factor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_tensor_affine_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(double _grad_factor)));
+  }|]
+
+_fake_quantize_learnable_per_tensor_affine_out_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_fake_quantize_learnable_per_tensor_affine_out_ttttll _out _self _scale _zero_point _quant_min _quant_max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_tensor_affine_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+fake_quantize_per_channel_affine_cachemask_out_tttttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+fake_quantize_per_channel_affine_cachemask_out_tttttlll _out0 _out1 _self _scale _zero_point _axis _quant_min _quant_max =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fake_quantize_per_channel_affine_cachemask_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+_fake_quantize_learnable_per_channel_affine_out_ttttllld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+_fake_quantize_learnable_per_channel_affine_out_ttttllld _out _self _scale _zero_point _axis _quant_min _quant_max _grad_factor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_channel_affine_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(double _grad_factor)));
+  }|]
+
+_fake_quantize_learnable_per_channel_affine_out_ttttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_fake_quantize_learnable_per_channel_affine_out_ttttlll _out _self _scale _zero_point _axis _quant_min _quant_max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_channel_affine_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlllbb _out0 _out1 _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis _per_row_fake_quant _symmetric_quant =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)
+  , $(bool _per_row_fake_quant)
+  , $(bool _symmetric_quant)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlllb _out0 _out1 _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis _per_row_fake_quant =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)
+  , $(bool _per_row_fake_quant)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_out_tttttttttdlll _out0 _out1 _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlllbb _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis _per_row_fake_quant _symmetric_quant =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_functional(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)
+  , $(bool _per_row_fake_quant)
+  , $(bool _symmetric_quant)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlllb _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis _per_row_fake_quant =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_functional(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)
+  , $(bool _per_row_fake_quant)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_functional_tttttttdlll _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_functional(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)));
+  }|]
+
+_to_copy_out_ttbM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_to_copy_out_ttbM _out _self _non_blocking _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _non_blocking)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_to_copy_out_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_to_copy_out_ttb _out _self _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _non_blocking)));
+  }|]
+
+_to_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_to_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_lstm_mps_out_tttttttllbldbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_lstm_mps_out_tttttttllbldbbb _out0 _out1 _out2 _out3 _out4 _out5 _input _hx _params _has_biases _num_layers _dropout _train _bidirectional _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_lstm_mps_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _out4)
+  , *$(at::Tensor* _out5)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)));
+  }|]
+
+lstm_mps_backward_out_tlltttttttllbldbbb
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (())
+lstm_mps_backward_out_tlltttttttllbldbbb _out0 _out1 _out2 _grad_y _grad_hy _grad_cy _z_state _cell_state_fwd _input _layersOutputs _hx _params _has_biases _num_layers _dropout _train _bidirectional _batch_first =
+  [C.throwBlock| void {  (at::lstm_mps_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(std::vector<at::Tensor>* _out1)
+  , *$(std::vector<at::Tensor>* _out2)
+  , *$(at::Tensor* _grad_y)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , *$(at::Tensor* _z_state)
+  , *$(at::Tensor* _cell_state_fwd)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _layersOutputs)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)));
+  }|]
+
+_thnn_fused_lstm_cell_out_tttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_out_tttttttt _out0 _out1 _out2 _input_gates _hidden_gates _cx _input_bias _hidden_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _input_bias)
+  , *$(at::Tensor* _hidden_bias)));
+  }|]
+
+_thnn_fused_lstm_cell_out_ttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_out_ttttttt _out0 _out1 _out2 _input_gates _hidden_gates _cx _input_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _input_bias)));
+  }|]
+
+_thnn_fused_lstm_cell_out_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_out_tttttt _out0 _out1 _out2 _input_gates _hidden_gates _cx =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _cx)));
+  }|]
+
+_thnn_fused_lstm_cell_backward_impl_out_ttttttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_backward_impl_out_ttttttttb _out0 _out1 _out2 _grad_hy _grad_cy _cx _cy _workspace _has_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_backward_impl_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _cy)
+  , *$(at::Tensor* _workspace)
+  , $(bool _has_bias)));
+  }|]
+
+_thnn_fused_gru_cell_out_ttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_out_ttttttt _out0 _out1 _input_gates _hidden_gates _hx _input_bias _hidden_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _input_bias)
+  , *$(at::Tensor* _hidden_bias)));
+  }|]
+
+_thnn_fused_gru_cell_out_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_out_tttttt _out0 _out1 _input_gates _hidden_gates _hx _input_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _input_bias)));
+  }|]
+
+_thnn_fused_gru_cell_out_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_out_ttttt _out0 _out1 _input_gates _hidden_gates _hx =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _hx)));
+  }|]
+
+_thnn_fused_gru_cell_backward_out_tttttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_fused_gru_cell_backward_out_tttttttb _out0 _out1 _out2 _out3 _out4 _grad_hy _workspace _has_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _out3)
+  , *$(at::Tensor* _out4)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _workspace)
+  , $(bool _has_bias)));
+  }|]
+
+_pack_padded_sequence_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_pack_padded_sequence_out_ttttb _out0 _out1 _input _lengths _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_pack_padded_sequence_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _lengths)
+  , $(bool _batch_first)));
+  }|]
+
+set_out_ttS
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Storage
+  -> IO (Ptr Tensor)
+set_out_ttS _out _self _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Storage* _source)));
+  }|]
+
+set_tS
+  :: Ptr Tensor
+  -> Ptr Storage
+  -> IO (Ptr Tensor)
+set_tS _self _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set(
+    *$(at::Tensor* _self)
+  , *$(at::Storage* _source)));
+  }|]
+
+set_out_ttSlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Storage
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+set_out_ttSlll _out _self _source _storage_offset _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Storage* _source)
+  , $(int64_t _storage_offset)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+set_out_ttSll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Storage
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+set_out_ttSll _out _self _source _storage_offset _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Storage* _source)
+  , $(int64_t _storage_offset)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+set_tSlll
+  :: Ptr Tensor
+  -> Ptr Storage
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+set_tSlll _self _source _storage_offset _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set(
+    *$(at::Tensor* _self)
+  , *$(at::Storage* _source)
+  , $(int64_t _storage_offset)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+set_tSll
+  :: Ptr Tensor
+  -> Ptr Storage
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+set_tSll _self _source _storage_offset _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set(
+    *$(at::Tensor* _self)
+  , *$(at::Storage* _source)
+  , $(int64_t _storage_offset)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+set_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+set_out_ttt _out _self _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _source)));
+  }|]
+
+set_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+set_tt _self _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _source)));
+  }|]
+
+set_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+set_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+set_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+set_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set(
+    *$(at::Tensor* _self)));
+  }|]
+
+lift_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lift_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lift_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+lift_fresh_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lift_fresh_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lift_fresh_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+masked_fill_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+masked_fill_out_ttts _out _self _mask _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_fill_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , *$(at::Scalar* _value)));
+  }|]
+
+masked_fill_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+masked_fill_out_tttt _out _self _mask _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_fill_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , *$(at::Tensor* _value)));
+  }|]
+
+masked_scatter_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+masked_scatter_out_tttt _out _self _mask _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , *$(at::Tensor* _source)));
+  }|]
+
+_masked_softmax_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_masked_softmax_out_tttll _out _self _mask _dim _mask_type =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , $(int64_t _dim)
+  , $(int64_t _mask_type)));
+  }|]
+
+_masked_softmax_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_masked_softmax_out_tttl _out _self _mask _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , $(int64_t _dim)));
+  }|]
+
+_masked_softmax_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_masked_softmax_out_ttt _out _self _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_masked_softmax_backward_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_masked_softmax_backward_out_ttttl _out _grad_output _output _mask _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _mask)
+  , $(int64_t _dim)));
+  }|]
+
+_masked_softmax_backward_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_masked_softmax_backward_out_tttt _out _grad_output _output _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+put_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+put_out_ttttb _out _self _index _source _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::put_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , $(bool _accumulate)));
+  }|]
+
+put_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+put_out_tttt _out _self _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::put_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+index_fill_out_ttlts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+index_fill_out_ttlts _out _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_fill_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+index_fill_out_ttltt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_fill_out_ttltt _out _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_fill_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _value)));
+  }|]
+
+bitwise_and_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_and_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_and_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_or_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_or_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_or_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_xor_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_xor_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_xor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+__lshift___out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+__lshift___out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__lshift___out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+__lshift___out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+__lshift___out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__lshift___out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_left_shift_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_left_shift_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_left_shift_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+__rshift___out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+__rshift___out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__rshift___out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+__rshift___out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+__rshift___out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__rshift___out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_right_shift_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_right_shift_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_right_shift_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+random_out_ttllG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+random_out_ttllG _out _self _from _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _from)
+  , $(int64_t _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
+random_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+random_out_ttll _out _self _from _to =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _from)
+  , $(int64_t _to)));
+  }|]
+
+random_tllG
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+random_tllG _self _from _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random(
+    *$(at::Tensor* _self)
+  , $(int64_t _from)
+  , $(int64_t _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native15.hs b/src/Torch/Internal/Unmanaged/Native/Native15.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native15.hs
@@ -0,0 +1,4008 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native15 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+random_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+random_tll _self _from _to =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random(
+    *$(at::Tensor* _self)
+  , $(int64_t _from)
+  , $(int64_t _to)));
+  }|]
+
+random_out_ttlG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+random_out_ttlG _out _self _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
+random_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+random_out_ttl _out _self _to =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _to)));
+  }|]
+
+random_tlG
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+random_tlG _self _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random(
+    *$(at::Tensor* _self)
+  , $(int64_t _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
+random_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+random_tl _self _to =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random(
+    *$(at::Tensor* _self)
+  , $(int64_t _to)));
+  }|]
+
+random_out_ttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+random_out_ttG _out _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+random_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+random_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+random_tG
+  :: Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+random_tG _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random(
+    *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+random_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+random_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random(
+    *$(at::Tensor* _self)));
+  }|]
+
+uniform_out_ttddG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+uniform_out_ttddG _out _self _from _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::uniform_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _from)
+  , $(double _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
+uniform_out_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+uniform_out_ttdd _out _self _from _to =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::uniform_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _from)
+  , $(double _to)));
+  }|]
+
+uniform_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+uniform_out_ttd _out _self _from =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::uniform_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _from)));
+  }|]
+
+uniform_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+uniform_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::uniform_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+uniform_tddG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+uniform_tddG _self _from _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::uniform(
+    *$(at::Tensor* _self)
+  , $(double _from)
+  , $(double _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
+uniform_tdd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+uniform_tdd _self _from _to =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::uniform(
+    *$(at::Tensor* _self)
+  , $(double _from)
+  , $(double _to)));
+  }|]
+
+uniform_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+uniform_td _self _from =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::uniform(
+    *$(at::Tensor* _self)
+  , $(double _from)));
+  }|]
+
+uniform_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+uniform_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::uniform(
+    *$(at::Tensor* _self)));
+  }|]
+
+cauchy_out_ttddG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+cauchy_out_ttddG _out _self _median _sigma _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cauchy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _median)
+  , $(double _sigma)
+  , *$(at::Generator* _generator)));
+  }|]
+
+cauchy_out_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+cauchy_out_ttdd _out _self _median _sigma =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cauchy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _median)
+  , $(double _sigma)));
+  }|]
+
+cauchy_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+cauchy_out_ttd _out _self _median =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cauchy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _median)));
+  }|]
+
+cauchy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cauchy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cauchy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+cauchy_tddG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+cauchy_tddG _self _median _sigma _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cauchy(
+    *$(at::Tensor* _self)
+  , $(double _median)
+  , $(double _sigma)
+  , *$(at::Generator* _generator)));
+  }|]
+
+cauchy_tdd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+cauchy_tdd _self _median _sigma =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cauchy(
+    *$(at::Tensor* _self)
+  , $(double _median)
+  , $(double _sigma)));
+  }|]
+
+cauchy_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+cauchy_td _self _median =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cauchy(
+    *$(at::Tensor* _self)
+  , $(double _median)));
+  }|]
+
+cauchy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cauchy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cauchy(
+    *$(at::Tensor* _self)));
+  }|]
+
+log_normal_out_ttddG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+log_normal_out_ttddG _out _self _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _mean)
+  , $(double _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+log_normal_out_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+log_normal_out_ttdd _out _self _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _mean)
+  , $(double _std)));
+  }|]
+
+log_normal_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+log_normal_out_ttd _out _self _mean =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _mean)));
+  }|]
+
+log_normal_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+log_normal_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+log_normal_tddG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+log_normal_tddG _self _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_normal(
+    *$(at::Tensor* _self)
+  , $(double _mean)
+  , $(double _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+log_normal_tdd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+log_normal_tdd _self _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_normal(
+    *$(at::Tensor* _self)
+  , $(double _mean)
+  , $(double _std)));
+  }|]
+
+log_normal_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+log_normal_td _self _mean =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_normal(
+    *$(at::Tensor* _self)
+  , $(double _mean)));
+  }|]
+
+log_normal_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log_normal_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_normal(
+    *$(at::Tensor* _self)));
+  }|]
+
+exponential_out_ttdG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+exponential_out_ttdG _out _self _lambd _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exponential_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _lambd)
+  , *$(at::Generator* _generator)));
+  }|]
+
+exponential_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+exponential_out_ttd _out _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exponential_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _lambd)));
+  }|]
+
+exponential_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+exponential_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exponential_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+exponential_tdG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+exponential_tdG _self _lambd _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exponential(
+    *$(at::Tensor* _self)
+  , $(double _lambd)
+  , *$(at::Generator* _generator)));
+  }|]
+
+exponential_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+exponential_td _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exponential(
+    *$(at::Tensor* _self)
+  , $(double _lambd)));
+  }|]
+
+exponential_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+exponential_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exponential(
+    *$(at::Tensor* _self)));
+  }|]
+
+geometric_out_ttdG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+geometric_out_ttdG _out _self _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::geometric_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+geometric_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+geometric_out_ttd _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::geometric_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+geometric_tdG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+geometric_tdG _self _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::geometric(
+    *$(at::Tensor* _self)
+  , $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+geometric_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+geometric_td _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::geometric(
+    *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+tril_indices_out_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tril_indices_out_tlll _out _row _col _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril_indices_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)));
+  }|]
+
+tril_indices_out_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tril_indices_out_tll _out _row _col =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril_indices_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _row)
+  , $(int64_t _col)));
+  }|]
+
+triu_indices_out_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+triu_indices_out_tlll _out _row _col _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu_indices_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)));
+  }|]
+
+triu_indices_out_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+triu_indices_out_tll _out _row _col =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu_indices_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _row)
+  , $(int64_t _col)));
+  }|]
+
+trace_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+trace_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trace_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_cholesky_solve_helper_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cholesky_solve_helper_out_tttb _out _self _A _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cholesky_solve_helper_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)
+  , $(bool _upper)));
+  }|]
+
+dist_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+dist_out_ttts _out _self _other _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dist_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _p)));
+  }|]
+
+dist_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+dist_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dist_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+_histogramdd_bin_edges_out_ltlatb
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> CBool
+  -> IO (())
+_histogramdd_bin_edges_out_ltlatb _out _self _bins _range _weight _density =
+  [C.throwBlock| void {  (at::_histogramdd_bin_edges_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+_histogramdd_bin_edges_out_ltlat
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> IO (())
+_histogramdd_bin_edges_out_ltlat _out _self _bins _range _weight =
+  [C.throwBlock| void {  (at::_histogramdd_bin_edges_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+_histogramdd_bin_edges_out_ltla
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (())
+_histogramdd_bin_edges_out_ltla _out _self _bins _range =
+  [C.throwBlock| void {  (at::_histogramdd_bin_edges_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)));
+  }|]
+
+_histogramdd_bin_edges_out_ltl
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+_histogramdd_bin_edges_out_ltl _out _self _bins =
+  [C.throwBlock| void {  (at::_histogramdd_bin_edges_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)));
+  }|]
+
+_histogramdd_from_bin_cts_out_ttlatb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_cts_out_ttlatb _out _self _bins _range _weight _density =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_cts_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+_histogramdd_from_bin_cts_out_ttlat
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_cts_out_ttlat _out _self _bins _range _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_cts_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+_histogramdd_from_bin_cts_out_ttla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_cts_out_ttla _out _self _bins _range =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_cts_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)));
+  }|]
+
+_histogramdd_from_bin_cts_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_cts_out_ttl _out _self _bins =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_cts_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)));
+  }|]
+
+_histogramdd_from_bin_tensors_out_ttltb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_tensors_out_ttltb _out _self _bins _weight _density =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_tensors_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Tensor>* _bins)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+_histogramdd_from_bin_tensors_out_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_tensors_out_ttlt _out _self _bins _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_tensors_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Tensor>* _bins)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+_histogramdd_from_bin_tensors_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_tensors_out_ttl _out _self _bins =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_tensors_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Tensor>* _bins)));
+  }|]
+
+remainder_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+remainder_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::remainder_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+argsort_out_ttblb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+argsort_out_ttblb _out _self _stable _dim _descending =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _stable)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+argsort_out_ttbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+argsort_out_ttbl _out _self _stable _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _stable)
+  , $(int64_t _dim)));
+  }|]
+
+argsort_out_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+argsort_out_ttb _out _self _stable =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _stable)));
+  }|]
+
+unfold_backward_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+unfold_backward_out_ttllll _out _grad_in _input_sizes _dim _size _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unfold_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_in)
+  , *$(std::vector<int64_t>* _input_sizes)
+  , $(int64_t _dim)
+  , $(int64_t _size)
+  , $(int64_t _step)));
+  }|]
+
+normal_out_ttddG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_out_ttddG _out _self _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _mean)
+  , $(double _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_out_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+normal_out_ttdd _out _self _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _mean)
+  , $(double _std)));
+  }|]
+
+-- normal_out_ttd
+--   :: Ptr Tensor
+--   -> Ptr Tensor
+--   -> CDouble
+--   -> IO (Ptr Tensor)
+-- normal_out_ttd _out _self _mean =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+--     *$(at::Tensor* _out)
+--   , *$(at::Tensor* _self)
+--   , $(double _mean)));
+--   }|]
+
+-- normal_out_tt
+--   :: Ptr Tensor
+--   -> Ptr Tensor
+--   -> IO (Ptr Tensor)
+-- normal_out_tt _out _self =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+--     *$(at::Tensor* _out)
+--   , *$(at::Tensor* _self)));
+--   }|]
+
+_amp_foreach_non_finite_check_and_unscale_out_lltt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+_amp_foreach_non_finite_check_and_unscale_out_lltt _out _self _found_inf _inv_scale =
+  [C.throwBlock| void {  (at::_amp_foreach_non_finite_check_and_unscale_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Tensor* _found_inf)
+  , *$(at::Tensor* _inv_scale)));
+  }|]
+
+_amp_foreach_non_finite_check_and_unscale_ltt
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(TensorList,Tensor)))
+_amp_foreach_non_finite_check_and_unscale_ltt _self _found_inf _inv_scale =
+  [C.throwBlock| std::tuple<std::vector<at::Tensor>,at::Tensor>* { return new std::tuple<std::vector<at::Tensor>,at::Tensor>(at::_amp_foreach_non_finite_check_and_unscale(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Tensor* _found_inf)
+  , *$(at::Tensor* _inv_scale)));
+  }|]
+
+_amp_update_scale_out_ttttddl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_amp_update_scale_out_ttttddl _out _self _growth_tracker _found_inf _scale_growth_factor _scale_backoff_factor _growth_interval =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_amp_update_scale_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _growth_tracker)
+  , *$(at::Tensor* _found_inf)
+  , $(double _scale_growth_factor)
+  , $(double _scale_backoff_factor)
+  , $(int64_t _growth_interval)));
+  }|]
+
+_amp_update_scale_tttddl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_amp_update_scale_tttddl _self _growth_tracker _found_inf _scale_growth_factor _scale_backoff_factor _growth_interval =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_amp_update_scale(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _growth_tracker)
+  , *$(at::Tensor* _found_inf)
+  , $(double _scale_growth_factor)
+  , $(double _scale_backoff_factor)
+  , $(int64_t _growth_interval)));
+  }|]
+
+_foreach_add_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_add_out_lls _out _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_add_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_sub_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_sub_out_lls _out _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_sub_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_mul_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_mul_out_lls _out _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_mul_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_div_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_div_out_lls _out _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_div_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_clamp_min_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_clamp_min_out_lls _out _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_clamp_min_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_clamp_max_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_clamp_max_out_lls _out _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_clamp_max_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_maximum_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_maximum_out_lls _out _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_maximum_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_minimum_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_minimum_out_lls _out _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_minimum_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_add_out_llls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_add_out_llls _out _self _other _alpha =
+  [C.throwBlock| void {  (at::_foreach_add_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_foreach_add_out_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_add_out_lll _out _self _other =
+  [C.throwBlock| void {  (at::_foreach_add_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_sub_out_llls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_sub_out_llls _out _self _other _alpha =
+  [C.throwBlock| void {  (at::_foreach_sub_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_foreach_sub_out_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_sub_out_lll _out _self _other =
+  [C.throwBlock| void {  (at::_foreach_sub_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_mul_out_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_mul_out_lll _out _self _other =
+  [C.throwBlock| void {  (at::_foreach_mul_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_div_out_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_div_out_lll _out _self _other =
+  [C.throwBlock| void {  (at::_foreach_div_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_clamp_min_out_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_clamp_min_out_lll _out _self _other =
+  [C.throwBlock| void {  (at::_foreach_clamp_min_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_clamp_max_out_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_clamp_max_out_lll _out _self _other =
+  [C.throwBlock| void {  (at::_foreach_clamp_max_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_maximum_out_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_maximum_out_lll _out _self _other =
+  [C.throwBlock| void {  (at::_foreach_maximum_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_minimum_out_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_minimum_out_lll _out _self _other =
+  [C.throwBlock| void {  (at::_foreach_minimum_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_add_out_llA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_add_out_llA _out _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_add_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_sub_out_llA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_sub_out_llA _out _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_sub_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_div_out_llA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_div_out_llA _out _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_div_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_mul_out_llA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_mul_out_llA _out _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_mul_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_clamp_min_out_llA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_clamp_min_out_llA _out _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_clamp_min_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_clamp_max_out_llA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_clamp_max_out_llA _out _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_clamp_max_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_maximum_out_llA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_maximum_out_llA _out _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_maximum_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_minimum_out_llA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_minimum_out_llA _out _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_minimum_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_exp_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_exp_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_exp_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_zero_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_zero_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_zero_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_zero_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_zero_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_zero(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sqrt_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_sqrt_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_sqrt_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_abs_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_abs_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_abs_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_acos_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_acos_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_acos_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_asin_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_asin_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_asin_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_atan_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_atan_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_atan_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_ceil_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_ceil_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_ceil_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_cos_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_cos_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_cos_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_cosh_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_cosh_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_cosh_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_erf_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_erf_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_erf_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_erfc_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_erfc_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_erfc_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_expm1_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_expm1_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_expm1_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_floor_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_floor_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_floor_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_log_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_log_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log10_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_log10_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_log10_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log1p_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_log1p_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_log1p_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log2_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_log2_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_log2_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_neg_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_neg_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_neg_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_tan_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_tan_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_tan_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_tanh_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_tanh_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_tanh_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sin_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_sin_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_sin_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sinh_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_sinh_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_sinh_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_round_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_round_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_round_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_lgamma_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_lgamma_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_lgamma_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_frac_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_frac_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_frac_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_reciprocal_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_reciprocal_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_reciprocal_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sigmoid_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_sigmoid_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_sigmoid_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_trunc_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_trunc_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_trunc_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_addcdiv_out_lllls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_addcdiv_out_lllls _out _self _tensor1 _tensor2 _value =
+  [C.throwBlock| void {  (at::_foreach_addcdiv_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+_foreach_addcdiv_out_llll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_addcdiv_out_llll _out _self _tensor1 _tensor2 =
+  [C.throwBlock| void {  (at::_foreach_addcdiv_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)));
+  }|]
+
+_foreach_addcmul_out_lllls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_addcmul_out_lllls _out _self _tensor1 _tensor2 _value =
+  [C.throwBlock| void {  (at::_foreach_addcmul_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+_foreach_addcmul_out_llll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_addcmul_out_llll _out _self _tensor1 _tensor2 =
+  [C.throwBlock| void {  (at::_foreach_addcmul_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)));
+  }|]
+
+_foreach_addcdiv_out_llllA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_addcdiv_out_llllA _out _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| void {  (at::_foreach_addcdiv_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_addcdiv_out_llllt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> IO (())
+_foreach_addcdiv_out_llllt _out _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| void {  (at::_foreach_addcdiv_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Tensor* _scalars)));
+  }|]
+
+_foreach_addcmul_out_llllA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_addcmul_out_llllA _out _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| void {  (at::_foreach_addcmul_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_addcmul_out_llllt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> IO (())
+_foreach_addcmul_out_llllt _out _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| void {  (at::_foreach_addcmul_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Tensor* _scalars)));
+  }|]
+
+_foreach_norm_out_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_norm_out_lls _out _self _ord =
+  [C.throwBlock| void {  (at::_foreach_norm_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _ord)));
+  }|]
+
+_foreach_norm_out_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_norm_out_ll _out _self =
+  [C.throwBlock| void {  (at::_foreach_norm_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_lerp_out_llll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_lerp_out_llll _out _self _tensors1 _weights =
+  [C.throwBlock| void {  (at::_foreach_lerp_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensors1)
+  , *$(std::vector<at::Tensor>* _weights)));
+  }|]
+
+_foreach_lerp_out_llls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_lerp_out_llls _out _self _tensors1 _weight =
+  [C.throwBlock| void {  (at::_foreach_lerp_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensors1)
+  , *$(at::Scalar* _weight)));
+  }|]
+
+bucketize_out_tstbb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+bucketize_out_tstbb _out _self _boundaries _out_int32 _right =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _boundaries)
+  , $(bool _out_int32)
+  , $(bool _right)));
+  }|]
+
+bucketize_out_tstb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+bucketize_out_tstb _out _self _boundaries _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _boundaries)
+  , $(bool _out_int32)));
+  }|]
+
+bucketize_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bucketize_out_tst _out _self _boundaries =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _boundaries)));
+  }|]
+
+searchsorted_out_ttsbbst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+searchsorted_out_ttsbbst _out _sorted_sequence _self _out_int32 _right _side _sorter =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)
+  , $(bool _out_int32)
+  , $(bool _right)
+  , *$(std::string* _side)
+  , *$(at::Tensor* _sorter)));
+  }|]
+
+searchsorted_out_ttsbbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+searchsorted_out_ttsbbs _out _sorted_sequence _self _out_int32 _right _side =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)
+  , $(bool _out_int32)
+  , $(bool _right)
+  , *$(std::string* _side)));
+  }|]
+
+searchsorted_out_ttsbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+searchsorted_out_ttsbb _out _sorted_sequence _self _out_int32 _right =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)
+  , $(bool _out_int32)
+  , $(bool _right)));
+  }|]
+
+searchsorted_out_ttsb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+searchsorted_out_ttsb _out _sorted_sequence _self _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)
+  , $(bool _out_int32)));
+  }|]
+
+searchsorted_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+searchsorted_out_tts _out _sorted_sequence _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)));
+  }|]
+
+glu_jvp_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+glu_jvp_out_ttttl _out _glu _x _dx _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_jvp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _glu)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _dx)
+  , $(int64_t _dim)));
+  }|]
+
+glu_backward_jvp_out_ttttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+glu_backward_jvp_out_ttttttl _out _grad_x _grad_glu _x _dgrad_glu _dx _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_backward_jvp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_x)
+  , *$(at::Tensor* _grad_glu)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _dgrad_glu)
+  , *$(at::Tensor* _dx)
+  , $(int64_t _dim)));
+  }|]
+
+hardswish_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hardswish_backward_out_ttt _out _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardswish_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+rrelu_with_noise_backward_out_ttttssbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+rrelu_with_noise_backward_out_ttttssbb _out _grad_output _self _noise _lower _upper _training _self_is_result =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)
+  , $(bool _self_is_result)));
+  }|]
+
+mkldnn_adaptive_avg_pool2d_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_adaptive_avg_pool2d_backward_out_ttt _out _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_adaptive_avg_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_adaptive_avg_pool2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_adaptive_avg_pool2d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_adaptive_avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+_adaptive_avg_pool2d_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_adaptive_avg_pool2d_backward_out_ttt _out _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_adaptive_avg_pool2d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_adaptive_avg_pool3d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_adaptive_avg_pool3d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_adaptive_avg_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+_adaptive_avg_pool3d_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_adaptive_avg_pool3d_backward_out_ttt _out _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_adaptive_avg_pool3d_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_slow_conv2d_backward_out_ttttttllla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_slow_conv2d_backward_out_ttttttllla _out0 _out1 _out2 _grad_output _self _weight _kernel_size _stride _padding _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_slow_conv2d_backward_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _out2)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+conv_depthwise3d_out_tttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+conv_depthwise3d_out_tttltlll _out _self _weight _kernel_size _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::conv_depthwise3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_dilated2d_out_tttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_out_tttltlll _out _self _weight _kernel_size _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_dilated2d_out_tttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_out_tttltll _out _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_dilated2d_out_tttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_out_tttltl _out _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv_dilated2d_out_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_out_tttlt _out _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv_dilated2d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated2d_out_tttl _out _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+slow_conv_dilated3d_out_tttltlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_out_tttltlll _out _self _weight _kernel_size _bias _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+slow_conv_dilated3d_out_tttltll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_out_tttltll _out _self _weight _kernel_size _bias _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+slow_conv_dilated3d_out_tttltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_out_tttltl _out _self _weight _kernel_size _bias _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+slow_conv_dilated3d_out_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_out_tttlt _out _self _weight _kernel_size _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+slow_conv_dilated3d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+slow_conv_dilated3d_out_tttl _out _self _weight _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slow_conv_dilated3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+isinf_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isinf_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isinf_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linalg_matrix_exp_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_matrix_exp_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_exp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_test_optional_intlist_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_test_optional_intlist_out_ttl _out _values _addends =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_intlist_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _addends)));
+  }|]
+
+_test_optional_filled_intlist_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_test_optional_filled_intlist_out_ttl _out _values _addends =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_filled_intlist_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _addends)));
+  }|]
+
+_test_optional_floatlist_out_tta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_test_optional_floatlist_out_tta _out _values _addends =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_floatlist_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<double>* _addends)));
+  }|]
+
+_test_warn_in_autograd_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_warn_in_autograd_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_warn_in_autograd_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_test_autograd_multiple_dispatch_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_autograd_multiple_dispatch_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_autograd_multiple_dispatch_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_test_autograd_multiple_dispatch_view_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_test_autograd_multiple_dispatch_view_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_autograd_multiple_dispatch_view_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+segment_reduce_out_ttstttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+segment_reduce_out_ttstttlbs _out _data _reduce _lengths _indices _offsets _axis _unsafe _initial =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)
+  , $(bool _unsafe)
+  , *$(at::Scalar* _initial)));
+  }|]
+
+segment_reduce_out_ttstttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+segment_reduce_out_ttstttlb _out _data _reduce _lengths _indices _offsets _axis _unsafe =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)
+  , $(bool _unsafe)));
+  }|]
+
+segment_reduce_out_ttstttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+segment_reduce_out_ttstttl _out _data _reduce _lengths _indices _offsets _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)));
+  }|]
+
+segment_reduce_out_ttsttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+segment_reduce_out_ttsttt _out _data _reduce _lengths _indices _offsets =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)));
+  }|]
+
+segment_reduce_out_ttstt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+segment_reduce_out_ttstt _out _data _reduce _lengths _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+segment_reduce_out_ttst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+segment_reduce_out_ttst _out _data _reduce _lengths =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)));
+  }|]
+
+segment_reduce_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+segment_reduce_out_tts _out _data _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)));
+  }|]
+
+_segment_reduce_backward_out_ttttsttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_out_ttttsttls _out _grad _output _data _reduce _lengths _offsets _axis _initial =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)
+  , *$(at::Scalar* _initial)));
+  }|]
+
+_segment_reduce_backward_out_ttttsttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_out_ttttsttl _out _grad _output _data _reduce _lengths _offsets _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _offsets)
+  , $(int64_t _axis)));
+  }|]
+
+_segment_reduce_backward_out_ttttstt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_out_ttttstt _out _grad _output _data _reduce _lengths _offsets =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)
+  , *$(at::Tensor* _offsets)));
+  }|]
+
+_segment_reduce_backward_out_ttttst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_out_ttttst _out _grad _output _data _reduce _lengths =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _lengths)));
+  }|]
+
+_segment_reduce_backward_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+_segment_reduce_backward_out_tttts _out _grad _output _data _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _data)
+  , *$(std::string* _reduce)));
+  }|]
+
+_nested_tensor_from_tensor_list_out_tlsLDb
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> ScalarType
+  -> Layout
+  -> DeviceType
+  -> CBool
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_out_tlsLDb _out _list _dtype _layout _device _pin_memory =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _list)
+  , $(at::ScalarType _dtype)
+  , $(at::Layout _layout)
+  , $(at::DeviceType _device)
+  , $(bool _pin_memory)));
+  }|]
+
+_nested_tensor_from_tensor_list_out_tlsLD
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> ScalarType
+  -> Layout
+  -> DeviceType
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_out_tlsLD _out _list _dtype _layout _device =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _list)
+  , $(at::ScalarType _dtype)
+  , $(at::Layout _layout)
+  , $(at::DeviceType _device)));
+  }|]
+
+_nested_tensor_from_tensor_list_out_tlsL
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> ScalarType
+  -> Layout
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_out_tlsL _out _list _dtype _layout =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _list)
+  , $(at::ScalarType _dtype)
+  , $(at::Layout _layout)));
+  }|]
+
+_nested_tensor_from_tensor_list_out_tls
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_out_tls _out _list _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _list)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_nested_tensor_from_tensor_list_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+_nested_tensor_from_tensor_list_out_tl _out _list =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _list)));
+  }|]
+
+_fw_primal_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_fw_primal_copy_out_ttl _out _self _level =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fw_primal_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _level)));
+  }|]
+
+_make_dual_copy_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_make_dual_copy_out_tttl _out _primal _tangent _level =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_dual_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _primal)
+  , *$(at::Tensor* _tangent)
+  , $(int64_t _level)));
+  }|]
+
+view_as_real_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+view_as_real_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_as_real_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+view_as_complex_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+view_as_complex_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_as_complex_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_conj_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_conj_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_conj_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_neg_view_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_neg_view_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_neg_view_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+as_strided_copy_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+as_strided_copy_out_ttlll _out _self _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+as_strided_copy_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+as_strided_copy_out_ttll _out _self _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+_sparse_broadcast_to_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_broadcast_to_copy_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_broadcast_to_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+diagonal_copy_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_copy_out_ttlll _out _self _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+diagonal_copy_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_copy_out_ttll _out _self _offset _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)));
+  }|]
+
+diagonal_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_copy_out_ttl _out _self _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _offset)));
+  }|]
+
+diagonal_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diagonal_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+expand_copy_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+expand_copy_out_ttlb _out _self _size _implicit =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expand_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(bool _implicit)));
+  }|]
+
+expand_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+expand_copy_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expand_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+permute_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+permute_copy_out_ttl _out _self _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::permute_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+_reshape_alias_copy_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_reshape_alias_copy_out_ttll _out _self _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_reshape_alias_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+select_copy_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+select_copy_out_ttll _out _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+detach_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+detach_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::detach_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+slice_copy_out_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_copy_out_ttllll _out _self _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+slice_copy_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_copy_out_ttlll _out _self _dim _start _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)));
+  }|]
+
+slice_copy_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_copy_out_ttll _out _self _dim _start =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)));
+  }|]
+
+slice_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_copy_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+slice_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slice_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+squeeze_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+squeeze_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::squeeze_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+squeeze_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+squeeze_copy_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::squeeze_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+t_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+t_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::t_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+transpose_copy_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+transpose_copy_out_ttll _out _self _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::transpose_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+unsqueeze_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+unsqueeze_copy_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unsqueeze_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+_indices_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_indices_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_indices_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_values_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_values_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_values_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+indices_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+indices_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::indices_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+values_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+values_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::values_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+crow_indices_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+crow_indices_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::crow_indices_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+col_indices_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+col_indices_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::col_indices_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+ccol_indices_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ccol_indices_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ccol_indices_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+row_indices_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+row_indices_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::row_indices_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+view_copy_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+view_copy_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+view_copy_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+view_copy_out_tts _out _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+unfold_copy_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+unfold_copy_out_ttlll _out _self _dimension _size _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unfold_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dimension)
+  , $(int64_t _size)
+  , $(int64_t _step)));
+  }|]
+
+alias_copy_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+alias_copy_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::alias_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+to_padded_tensor_out_ttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+to_padded_tensor_out_ttdl _out _self _padding _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::to_padded_tensor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _padding)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+to_padded_tensor_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+to_padded_tensor_out_ttd _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::to_padded_tensor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _padding)));
+  }|]
+
+_transformer_encoder_layer_fwd_out_ttllttttbbdtttttttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_transformer_encoder_layer_fwd_out_ttllttttbbdtttttttttl _out _src _embed_dim _num_heads _qkv_weight _qkv_bias _proj_weight _proj_bias _use_gelu _norm_first _eps _norm_weight_1 _norm_bias_1 _norm_weight_2 _norm_bias_2 _ffn_weight_1 _ffn_bias_1 _ffn_weight_2 _ffn_bias_2 _mask _mask_type =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _src)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_heads)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , $(bool _use_gelu)
+  , $(bool _norm_first)
+  , $(double _eps)
+  , *$(at::Tensor* _norm_weight_1)
+  , *$(at::Tensor* _norm_bias_1)
+  , *$(at::Tensor* _norm_weight_2)
+  , *$(at::Tensor* _norm_bias_2)
+  , *$(at::Tensor* _ffn_weight_1)
+  , *$(at::Tensor* _ffn_bias_1)
+  , *$(at::Tensor* _ffn_weight_2)
+  , *$(at::Tensor* _ffn_bias_2)
+  , *$(at::Tensor* _mask)
+  , $(int64_t _mask_type)));
+  }|]
+
+_transformer_encoder_layer_fwd_out_ttllttttbbdttttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_transformer_encoder_layer_fwd_out_ttllttttbbdttttttttt _out _src _embed_dim _num_heads _qkv_weight _qkv_bias _proj_weight _proj_bias _use_gelu _norm_first _eps _norm_weight_1 _norm_bias_1 _norm_weight_2 _norm_bias_2 _ffn_weight_1 _ffn_bias_1 _ffn_weight_2 _ffn_bias_2 _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _src)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_heads)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , $(bool _use_gelu)
+  , $(bool _norm_first)
+  , $(double _eps)
+  , *$(at::Tensor* _norm_weight_1)
+  , *$(at::Tensor* _norm_bias_1)
+  , *$(at::Tensor* _norm_weight_2)
+  , *$(at::Tensor* _norm_bias_2)
+  , *$(at::Tensor* _ffn_weight_1)
+  , *$(at::Tensor* _ffn_bias_1)
+  , *$(at::Tensor* _ffn_weight_2)
+  , *$(at::Tensor* _ffn_bias_2)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_transformer_encoder_layer_fwd_out_ttllttttbbdtttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_transformer_encoder_layer_fwd_out_ttllttttbbdtttttttt _out _src _embed_dim _num_heads _qkv_weight _qkv_bias _proj_weight _proj_bias _use_gelu _norm_first _eps _norm_weight_1 _norm_bias_1 _norm_weight_2 _norm_bias_2 _ffn_weight_1 _ffn_bias_1 _ffn_weight_2 _ffn_bias_2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _src)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_heads)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , $(bool _use_gelu)
+  , $(bool _norm_first)
+  , $(double _eps)
+  , *$(at::Tensor* _norm_weight_1)
+  , *$(at::Tensor* _norm_bias_1)
+  , *$(at::Tensor* _norm_weight_2)
+  , *$(at::Tensor* _norm_bias_2)
+  , *$(at::Tensor* _ffn_weight_1)
+  , *$(at::Tensor* _ffn_bias_1)
+  , *$(at::Tensor* _ffn_weight_2)
+  , *$(at::Tensor* _ffn_bias_2)));
+  }|]
+
+_native_multi_head_attention_out_tttttlltttttbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttlltttttbbl _out0 _out1 _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask _need_weights _average_attn_weights _mask_type =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)
+  , $(bool _need_weights)
+  , $(bool _average_attn_weights)
+  , $(int64_t _mask_type)));
+  }|]
+
+_native_multi_head_attention_out_tttttlltttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttlltttttbb _out0 _out1 _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask _need_weights _average_attn_weights =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)
+  , $(bool _need_weights)
+  , $(bool _average_attn_weights)));
+  }|]
+
+_native_multi_head_attention_out_tttttlltttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttlltttttb _out0 _out1 _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask _need_weights =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)
+  , $(bool _need_weights)));
+  }|]
+
+_native_multi_head_attention_out_tttttllttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttllttttt _out0 _out1 _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_native_multi_head_attention_out_tttttlltttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_native_multi_head_attention_out_tttttlltttt _out0 _out1 _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention_out(
+    *$(at::Tensor* _out0)
+  , *$(at::Tensor* _out1)
+  , *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)));
+  }|]
+
+_triton_scaled_dot_attention_out_ttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+_triton_scaled_dot_attention_out_ttttd _out _q _k _v _dropout_p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_scaled_dot_attention_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _q)
+  , *$(at::Tensor* _k)
+  , *$(at::Tensor* _v)
+  , $(double _dropout_p)));
+  }|]
+
+_triton_scaled_dot_attention_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_triton_scaled_dot_attention_out_tttt _out _q _k _v =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_scaled_dot_attention_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _q)
+  , *$(at::Tensor* _k)
+  , *$(at::Tensor* _v)));
+  }|]
+
+_triton_multi_head_attention_out_ttttllttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_triton_multi_head_attention_out_ttttllttttt _out _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_multi_head_attention_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_triton_multi_head_attention_out_ttttlltttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_triton_multi_head_attention_out_ttttlltttt _out _query _key _value _embed_dim _num_head _qkv_weight _qkv_bias _proj_weight _proj_bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_multi_head_attention_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _query)
+  , *$(at::Tensor* _key)
+  , *$(at::Tensor* _value)
+  , $(int64_t _embed_dim)
+  , $(int64_t _num_head)
+  , *$(at::Tensor* _qkv_weight)
+  , *$(at::Tensor* _qkv_bias)
+  , *$(at::Tensor* _proj_weight)
+  , *$(at::Tensor* _proj_bias)));
+  }|]
+
+_foobar_out_ttbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_foobar_out_ttbbb _out _self _arg1 _arg2 _arg3 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_foobar_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _arg1)
+  , $(bool _arg2)
+  , $(bool _arg3)));
+  }|]
+
+_foobar_out_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_foobar_out_ttbb _out _self _arg1 _arg2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_foobar_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _arg1)
+  , $(bool _arg2)));
+  }|]
+
+_foobar_out_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_foobar_out_ttb _out _self _arg1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_foobar_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _arg1)));
+  }|]
+
+_foobar_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_foobar_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_foobar_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_fused_adam_out_llllllldddddbbtt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+_fused_adam_out_llllllldddddbbtt _out _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale _found_inf =
+  [C.throwBlock| void {  (at::_fused_adam_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)
+  , *$(at::Tensor* _found_inf)));
+  }|]
+
+_fused_adam_out_llllllldddddbbt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> IO (())
+_fused_adam_out_llllllldddddbbt _out _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale =
+  [C.throwBlock| void {  (at::_fused_adam_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)));
+  }|]
+
+_fused_adam_out_llllllldddddbb
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (())
+_fused_adam_out_llllllldddddbb _out _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize =
+  [C.throwBlock| void {  (at::_fused_adam_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)));
+  }|]
+
+_fused_adam_lllllldddddbbtt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adam_lllllldddddbbtt _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale _found_inf =
+  [C.throwBlock| std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* { return new std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>(at::_fused_adam(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)
+  , *$(at::Tensor* _found_inf)));
+  }|]
+
+_fused_adam_lllllldddddbbt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adam_lllllldddddbbt _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale =
+  [C.throwBlock| std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* { return new std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>(at::_fused_adam(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)));
+  }|]
+
+_fused_adam_lllllldddddbb
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adam_lllllldddddbb _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize =
+  [C.throwBlock| std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* { return new std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>(at::_fused_adam(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)));
+  }|]
+
+_fused_adamw_out_llllllldddddbbtt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+_fused_adamw_out_llllllldddddbbtt _out _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale _found_inf =
+  [C.throwBlock| void {  (at::_fused_adamw_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)
+  , *$(at::Tensor* _found_inf)));
+  }|]
+
+_fused_adamw_out_llllllldddddbbt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> IO (())
+_fused_adamw_out_llllllldddddbbt _out _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale =
+  [C.throwBlock| void {  (at::_fused_adamw_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)));
+  }|]
+
+_fused_adamw_out_llllllldddddbb
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (())
+_fused_adamw_out_llllllldddddbb _out _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize =
+  [C.throwBlock| void {  (at::_fused_adamw_out(
+    *$(std::vector<at::Tensor>* _out)
+  , *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)));
+  }|]
+
+_fused_adamw_lllllldddddbbtt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adamw_lllllldddddbbtt _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale _found_inf =
+  [C.throwBlock| std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* { return new std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>(at::_fused_adamw(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)
+  , *$(at::Tensor* _found_inf)));
+  }|]
+
+_fused_adamw_lllllldddddbbt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adamw_lllllldddddbbt _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize _grad_scale =
+  [C.throwBlock| std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* { return new std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>(at::_fused_adamw(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)
+  , *$(at::Tensor* _grad_scale)));
+  }|]
+
+_fused_adamw_lllllldddddbb
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)))
+_fused_adamw_lllllldddddbb _self _grads _exp_avgs _exp_avg_sqs _max_exp_avg_sqs _state_steps _lr _beta1 _beta2 _weight_decay _eps _amsgrad _maximize =
+  [C.throwBlock| std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* { return new std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>(at::_fused_adamw(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _grads)
+  , *$(std::vector<at::Tensor>* _exp_avgs)
+  , *$(std::vector<at::Tensor>* _exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _max_exp_avg_sqs)
+  , *$(std::vector<at::Tensor>* _state_steps)
+  , $(double _lr)
+  , $(double _beta1)
+  , $(double _beta2)
+  , $(double _weight_decay)
+  , $(double _eps)
+  , $(bool _amsgrad)
+  , $(bool _maximize)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native2.hs b/src/Torch/Internal/Unmanaged/Native/Native2.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native2.hs
@@ -0,0 +1,3734 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native2 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+embedding_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+embedding_ttl _weight _indices _padding_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _padding_idx)));
+  }|]
+
+embedding_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+embedding_tt _weight _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+embedding_backward_ttllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+embedding_backward_ttllbb _grad _indices _num_weights _padding_idx _scale_grad_by_freq _sparse =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _num_weights)
+  , $(int64_t _padding_idx)
+  , $(bool _scale_grad_by_freq)
+  , $(bool _sparse)));
+  }|]
+
+embedding_dense_backward_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+embedding_dense_backward_ttllb _grad_output _indices _num_weights _padding_idx _scale_grad_by_freq =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_dense_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _num_weights)
+  , $(int64_t _padding_idx)
+  , $(bool _scale_grad_by_freq)));
+  }|]
+
+embedding_renorm__ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+embedding_renorm__ttdd _self _indices _max_norm _norm_type =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_renorm_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , $(double _max_norm)
+  , $(double _norm_type)));
+  }|]
+
+embedding_sparse_backward_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+embedding_sparse_backward_ttllb _grad _indices _num_weights _padding_idx _scale_grad_by_freq =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::embedding_sparse_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _num_weights)
+  , $(int64_t _padding_idx)
+  , $(bool _scale_grad_by_freq)));
+  }|]
+
+_embedding_bag_forward_only_tttblbtbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttblbtbl _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset _padding_idx =
+  [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_forward_only(
+    *$(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)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_forward_only_tttblbtb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_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_forward_only(
+    *$(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_forward_only_tttblbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_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_forward_only(
+    *$(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_forward_only_tttblb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_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_forward_only(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)));
+  }|]
+
+_embedding_bag_forward_only_tttbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttbl _weight _indices _offsets _scale_grad_by_freq _mode =
+  [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_forward_only(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)));
+  }|]
+
+_embedding_bag_forward_only_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_tttb _weight _indices _offsets _scale_grad_by_freq =
+  [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_forward_only(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)));
+  }|]
+
+_embedding_bag_forward_only_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_forward_only_ttt _weight _indices _offsets =
+  [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_forward_only(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)));
+  }|]
+
+_rowwise_prune_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_rowwise_prune_tts _weight _mask _compressed_indices_dtype =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_rowwise_prune(
+    *$(at::Tensor* _weight)
+  , *$(at::Tensor* _mask)
+  , $(at::ScalarType _compressed_indices_dtype)));
+  }|]
+
+row_stack_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+row_stack_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::row_stack(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+row_stack_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+row_stack_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::row_stack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+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
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+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)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)));
+  }|]
+
+embedding_bag_tttbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttbl _weight _indices _offsets _scale_grad_by_freq _mode =
+  [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)));
+  }|]
+
+embedding_bag_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttb _weight _indices _offsets _scale_grad_by_freq =
+  [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)));
+  }|]
+
+embedding_bag_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_ttt _weight _indices _offsets =
+  [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)));
+  }|]
+
+embedding_bag_tttblbtbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+embedding_bag_tttblbtbl _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset _padding_idx =
+  [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)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_tttblbtbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttblbtbl _weight _indices _offsets _scale_grad_by_freq _mode _sparse _per_sample_weights _include_last_offset _padding_idx =
+  [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)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_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
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_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)
+  , *$(at::Tensor* _offsets)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)));
+  }|]
+
+_embedding_bag_tttbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttbl _weight _indices _offsets _scale_grad_by_freq _mode =
+  [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)));
+  }|]
+
+_embedding_bag_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_tttb _weight _indices _offsets _scale_grad_by_freq =
+  [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)));
+  }|]
+
+_embedding_bag_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+_embedding_bag_ttt _weight _indices _offsets =
+  [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)));
+  }|]
+
+_embedding_bag_backward_ttttttlblbtl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_embedding_bag_backward_ttttttlblbtl _grad _indices _offsets _offset2bag _bag_size _maximum_indices _num_weights _scale_grad_by_freq _mode _sparse _per_sample_weights _padding_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , *$(at::Tensor* _offset2bag)
+  , *$(at::Tensor* _bag_size)
+  , *$(at::Tensor* _maximum_indices)
+  , $(int64_t _num_weights)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)
+  , *$(at::Tensor* _per_sample_weights)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_backward_ttttttlblbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_embedding_bag_backward_ttttttlblbt _grad _indices _offsets _offset2bag _bag_size _maximum_indices _num_weights _scale_grad_by_freq _mode _sparse _per_sample_weights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , *$(at::Tensor* _offset2bag)
+  , *$(at::Tensor* _bag_size)
+  , *$(at::Tensor* _maximum_indices)
+  , $(int64_t _num_weights)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , $(bool _sparse)
+  , *$(at::Tensor* _per_sample_weights)));
+  }|]
+
+_embedding_bag_sparse_backward_tttttlbltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_embedding_bag_sparse_backward_tttttlbltl _grad _indices _offsets _offset2bag _bag_size _num_weights _scale_grad_by_freq _mode _per_sample_weights _padding_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_sparse_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , *$(at::Tensor* _offset2bag)
+  , *$(at::Tensor* _bag_size)
+  , $(int64_t _num_weights)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , *$(at::Tensor* _per_sample_weights)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_sparse_backward_tttttlblt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_embedding_bag_sparse_backward_tttttlblt _grad _indices _offsets _offset2bag _bag_size _num_weights _scale_grad_by_freq _mode _per_sample_weights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_sparse_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , *$(at::Tensor* _offset2bag)
+  , *$(at::Tensor* _bag_size)
+  , $(int64_t _num_weights)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , *$(at::Tensor* _per_sample_weights)));
+  }|]
+
+_embedding_bag_dense_backward_tttttlbltl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_embedding_bag_dense_backward_tttttlbltl _grad _indices _offset2bag _bag_size _maximum_indices _num_weights _scale_grad_by_freq _mode _per_sample_weights _padding_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_dense_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offset2bag)
+  , *$(at::Tensor* _bag_size)
+  , *$(at::Tensor* _maximum_indices)
+  , $(int64_t _num_weights)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , *$(at::Tensor* _per_sample_weights)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_dense_backward_tttttlblt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_embedding_bag_dense_backward_tttttlblt _grad _indices _offset2bag _bag_size _maximum_indices _num_weights _scale_grad_by_freq _mode _per_sample_weights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_dense_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offset2bag)
+  , *$(at::Tensor* _bag_size)
+  , *$(at::Tensor* _maximum_indices)
+  , $(int64_t _num_weights)
+  , $(bool _scale_grad_by_freq)
+  , $(int64_t _mode)
+  , *$(at::Tensor* _per_sample_weights)));
+  }|]
+
+_embedding_bag_per_sample_weights_backward_tttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_embedding_bag_per_sample_weights_backward_tttttll _grad _weight _indices _offsets _offset2bag _mode _padding_idx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_per_sample_weights_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , *$(at::Tensor* _offset2bag)
+  , $(int64_t _mode)
+  , $(int64_t _padding_idx)));
+  }|]
+
+_embedding_bag_per_sample_weights_backward_tttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_embedding_bag_per_sample_weights_backward_tttttl _grad _weight _indices _offsets _offset2bag _mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_embedding_bag_per_sample_weights_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _offsets)
+  , *$(at::Tensor* _offset2bag)
+  , $(int64_t _mode)));
+  }|]
+
+empty_lNoM
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_lNoM _size _names _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+empty_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+empty_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+empty_loM
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_loM _size _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+empty_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+empty_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+_empty_affine_quantized_lodlM
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> CDouble
+  -> Int64
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_lodlM _size _options _scale _zero_point _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)
+  , $(double _scale)
+  , $(int64_t _zero_point)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_empty_affine_quantized_lodl
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_lodl _size _options _scale _zero_point =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)
+  , $(double _scale)
+  , $(int64_t _zero_point)));
+  }|]
+
+_empty_affine_quantized_lod
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> CDouble
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_lod _size _options _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)
+  , $(double _scale)));
+  }|]
+
+_empty_affine_quantized_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_empty_affine_quantized_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+_empty_per_channel_affine_quantized_lttloM
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_empty_per_channel_affine_quantized_lttloM _size _scales _zero_points _axis _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_per_channel_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_empty_per_channel_affine_quantized_lttlo
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_empty_per_channel_affine_quantized_lttlo _size _scales _zero_points _axis _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_per_channel_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_empty_per_channel_affine_quantized_lttl
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_empty_per_channel_affine_quantized_lttl _size _scales _zero_points _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_empty_per_channel_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)));
+  }|]
+
+_resize_output__tlD
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> DeviceType
+  -> IO (Ptr Tensor)
+_resize_output__tlD _self _size _device =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_resize_output_(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , $(at::DeviceType _device)));
+  }|]
+
+empty_quantized_ltoM
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_quantized_ltoM _size _qtensor _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _qtensor)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_quantized_lto
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_quantized_lto _size _qtensor _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _qtensor)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+empty_quantized_lt
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+empty_quantized_lt _size _qtensor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _qtensor)));
+  }|]
+
+empty_out_tlM
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_out_tlM _out _size _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_out_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+empty_out_tl _out _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+empty_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_strided_llo _size _stride _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_strided(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+empty_strided_ll
+  :: Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+empty_strided_ll _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::empty_strided(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+erf_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+erf_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::erf(
+    *$(at::Tensor* _self)));
+  }|]
+
+erf__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+erf__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::erf_(
+    *$(at::Tensor* _self)));
+  }|]
+
+erf_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+erf_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::erf_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+erfc_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+erfc_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::erfc(
+    *$(at::Tensor* _self)));
+  }|]
+
+erfc__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+erfc__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::erfc_(
+    *$(at::Tensor* _self)));
+  }|]
+
+erfc_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+erfc_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::erfc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+exp_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+exp_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exp(
+    *$(at::Tensor* _self)));
+  }|]
+
+exp__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+exp__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exp_(
+    *$(at::Tensor* _self)));
+  }|]
+
+exp_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+exp_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+exp2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+exp2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exp2(
+    *$(at::Tensor* _self)));
+  }|]
+
+exp2__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+exp2__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exp2_(
+    *$(at::Tensor* _self)));
+  }|]
+
+exp2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+exp2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::exp2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+expm1_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+expm1_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expm1(
+    *$(at::Tensor* _self)));
+  }|]
+
+expm1__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+expm1__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expm1_(
+    *$(at::Tensor* _self)));
+  }|]
+
+expm1_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+expm1_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expm1_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+eye_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+eye_lo _n _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eye(
+    $(int64_t _n)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+eye_l
+  :: Int64
+  -> IO (Ptr Tensor)
+eye_l _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eye(
+    $(int64_t _n)));
+  }|]
+
+eye_llo
+  :: Int64
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+eye_llo _n _m _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eye(
+    $(int64_t _n)
+  , $(int64_t _m)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+eye_ll
+  :: Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+eye_ll _n _m =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eye(
+    $(int64_t _n)
+  , $(int64_t _m)));
+  }|]
+
+eye_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+eye_out_tl _out _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eye_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)));
+  }|]
+
+eye_out_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+eye_out_tll _out _n _m =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eye_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)
+  , $(int64_t _m)));
+  }|]
+
+flatten_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+flatten_tll _self _start_dim _end_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flatten(
+    *$(at::Tensor* _self)
+  , $(int64_t _start_dim)
+  , $(int64_t _end_dim)));
+  }|]
+
+flatten_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+flatten_tl _self _start_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flatten(
+    *$(at::Tensor* _self)
+  , $(int64_t _start_dim)));
+  }|]
+
+flatten_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+flatten_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flatten(
+    *$(at::Tensor* _self)));
+  }|]
+
+flatten_tlln
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+flatten_tlln _self _start_dim _end_dim _out_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flatten(
+    *$(at::Tensor* _self)
+  , $(int64_t _start_dim)
+  , $(int64_t _end_dim)
+  , *$(at::Dimname* _out_dim)));
+  }|]
+
+flatten_tnnn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+flatten_tnnn _self _start_dim _end_dim _out_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flatten(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _start_dim)
+  , *$(at::Dimname* _end_dim)
+  , *$(at::Dimname* _out_dim)));
+  }|]
+
+flatten_tNn
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+flatten_tNn _self _dims _out_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flatten(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dims)
+  , *$(at::Dimname* _out_dim)));
+  }|]
+
+unflatten_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+unflatten_tll _self _dim _sizes =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unflatten(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(std::vector<int64_t>* _sizes)));
+  }|]
+
+unflatten_tnlN
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+unflatten_tnlN _self _dim _sizes _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unflatten(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(std::vector<int64_t>* _sizes)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+fill_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+fill_ts _self _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fill(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _value)));
+  }|]
+
+fill_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fill_tt _self _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fill(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _value)));
+  }|]
+
+fill__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+fill__ts _self _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fill_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _value)));
+  }|]
+
+fill__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fill__tt _self _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fill_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _value)));
+  }|]
+
+floor_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+floor_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::floor(
+    *$(at::Tensor* _self)));
+  }|]
+
+floor__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+floor__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::floor_(
+    *$(at::Tensor* _self)));
+  }|]
+
+floor_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+floor_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::floor_out(
+    *$(at::Tensor* _out)
+  , *$(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)
+frac_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::frac(
+    *$(at::Tensor* _self)));
+  }|]
+
+frac__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+frac__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::frac_(
+    *$(at::Tensor* _self)));
+  }|]
+
+frac_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+frac_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::frac_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+full_lsNo
+  :: Ptr IntArray
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+full_lsNo _size _fill_value _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+full_lsN
+  :: Ptr IntArray
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+full_lsN _size _fill_value _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+full_lso
+  :: Ptr IntArray
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+full_lso _size _fill_value _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+full_ls
+  :: Ptr IntArray
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+full_ls _size _fill_value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)));
+  }|]
+
+full_out_tls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+full_out_tls _out _size _fill_value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)));
+  }|]
+
+full_like_tsoM
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+full_like_tsoM _self _fill_value _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_like(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _fill_value)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+full_like_tso
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+full_like_tso _self _fill_value _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::full_like(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _fill_value)
+  , *$(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
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+from_file_sblo _filename _shared _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::from_file(
+    *$(std::string* _filename)
+  , $(bool _shared)
+  , $(int64_t _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+from_file_sbl
+  :: Ptr StdString
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+from_file_sbl _filename _shared _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::from_file(
+    *$(std::string* _filename)
+  , $(bool _shared)
+  , $(int64_t _size)));
+  }|]
+
+from_file_sb
+  :: Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+from_file_sb _filename _shared =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::from_file(
+    *$(std::string* _filename)
+  , $(bool _shared)));
+  }|]
+
+from_file_s
+  :: Ptr StdString
+  -> IO (Ptr Tensor)
+from_file_s _filename =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::from_file(
+    *$(std::string* _filename)));
+  }|]
+
+gcd_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gcd_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gcd_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+gcd_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gcd_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gcd(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+gcd__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gcd__tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gcd_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+lcm_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lcm_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lcm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+lcm_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lcm_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lcm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+lcm__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lcm__tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lcm_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+grid_sampler_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+grid_sampler_ttllb _input _grid _interpolation_mode _padding_mode _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::grid_sampler(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)));
+  }|]
+
+grid_sampler_2d_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+grid_sampler_2d_ttllb _input _grid _interpolation_mode _padding_mode _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::grid_sampler_2d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)));
+  }|]
+
+grid_sampler_2d_backward_tttllba
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+grid_sampler_2d_backward_tttllba _grad_output _input _grid _interpolation_mode _padding_mode _align_corners _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::grid_sampler_2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)
+  , *$(std::array<bool,2>* _output_mask)));
+  }|]
+
+_grid_sampler_2d_cpu_fallback_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_grid_sampler_2d_cpu_fallback_ttllb _input _grid _interpolation_mode _padding_mode _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_grid_sampler_2d_cpu_fallback(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)));
+  }|]
+
+_grid_sampler_2d_cpu_fallback_backward_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_grid_sampler_2d_cpu_fallback_backward_tttllb _grad_output _input _grid _interpolation_mode _padding_mode _align_corners =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_grid_sampler_2d_cpu_fallback_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)));
+  }|]
+
+grid_sampler_3d_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+grid_sampler_3d_ttllb _input _grid _interpolation_mode _padding_mode _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::grid_sampler_3d(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)));
+  }|]
+
+grid_sampler_3d_backward_tttllba
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+grid_sampler_3d_backward_tttllba _grad_output _input _grid _interpolation_mode _padding_mode _align_corners _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::grid_sampler_3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _grid)
+  , $(int64_t _interpolation_mode)
+  , $(int64_t _padding_mode)
+  , $(bool _align_corners)
+  , *$(std::array<bool,2>* _output_mask)));
+  }|]
+
+hann_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hann_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hann_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hann_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+hann_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hann_window(
+    $(int64_t _window_length)));
+  }|]
+
+hann_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hann_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hann_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hann_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+hann_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hann_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+hamming_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hamming_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hamming_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+hamming_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window(
+    $(int64_t _window_length)));
+  }|]
+
+hamming_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hamming_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hamming_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+hamming_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+hamming_window_lbdo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hamming_window_lbdo _window_length _periodic _alpha _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hamming_window_lbd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+hamming_window_lbd _window_length _periodic _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)));
+  }|]
+
+hamming_window_lbddo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hamming_window_lbddo _window_length _periodic _alpha _beta _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)
+  , $(double _beta)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hamming_window_lbdd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+hamming_window_lbdd _window_length _periodic _alpha _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)
+  , $(double _beta)));
+  }|]
+
+kaiser_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+kaiser_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+kaiser_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+kaiser_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window(
+    $(int64_t _window_length)));
+  }|]
+
+kaiser_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+kaiser_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+kaiser_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+kaiser_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+kaiser_window_lbdo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+kaiser_window_lbdo _window_length _periodic _beta _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _beta)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+kaiser_window_lbd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+kaiser_window_lbd _window_length _periodic _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kaiser_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _beta)));
+  }|]
+
+hinge_embedding_loss_ttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+hinge_embedding_loss_ttdl _self _target _margin _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hinge_embedding_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(double _margin)
+  , $(int64_t _reduction)));
+  }|]
+
+hinge_embedding_loss_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+hinge_embedding_loss_ttd _self _target _margin =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hinge_embedding_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(double _margin)));
+  }|]
+
+hinge_embedding_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hinge_embedding_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hinge_embedding_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+group_norm_tlttdb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+group_norm_tlttdb _input _num_groups _weight _bias _eps _cudnn_enabled =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::group_norm(
+    *$(at::Tensor* _input)
+  , $(int64_t _num_groups)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(double _eps)
+  , $(bool _cudnn_enabled)));
+  }|]
+
+group_norm_tlttd
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+group_norm_tlttd _input _num_groups _weight _bias _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::group_norm(
+    *$(at::Tensor* _input)
+  , $(int64_t _num_groups)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(double _eps)));
+  }|]
+
+group_norm_tltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+group_norm_tltt _input _num_groups _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::group_norm(
+    *$(at::Tensor* _input)
+  , $(int64_t _num_groups)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+group_norm_tlt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+group_norm_tlt _input _num_groups _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::group_norm(
+    *$(at::Tensor* _input)
+  , $(int64_t _num_groups)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+group_norm_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+group_norm_tl _input _num_groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::group_norm(
+    *$(at::Tensor* _input)
+  , $(int64_t _num_groups)));
+  }|]
+
+native_group_norm_tttlllld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_group_norm_tttlllld _input _weight _bias _N _C _HxW _group _eps =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_group_norm(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(int64_t _N)
+  , $(int64_t _C)
+  , $(int64_t _HxW)
+  , $(int64_t _group)
+  , $(double _eps)));
+  }|]
+
+native_group_norm_backward_tttttlllla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_group_norm_backward_tttttlllla _grad_out _input _mean _rstd _weight _N _C _HxW _group _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_group_norm_backward(
+    *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _rstd)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _N)
+  , $(int64_t _C)
+  , $(int64_t _HxW)
+  , $(int64_t _group)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+_fft_r2c_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_fft_r2c_tllb _self _dim _normalization _onesided =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fft_r2c(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _normalization)
+  , $(bool _onesided)));
+  }|]
+
+_fft_r2c_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_fft_r2c_out_ttllb _out _self _dim _normalization _onesided =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fft_r2c_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _normalization)
+  , $(bool _onesided)));
+  }|]
+
+_fft_c2r_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_fft_c2r_tlll _self _dim _normalization _last_dim_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fft_c2r(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _normalization)
+  , $(int64_t _last_dim_size)));
+  }|]
+
+_fft_c2r_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_fft_c2r_out_ttlll _out _self _dim _normalization _last_dim_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fft_c2r_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _normalization)
+  , $(int64_t _last_dim_size)));
+  }|]
+
+_fft_c2c_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_fft_c2c_tllb _self _dim _normalization _forward =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fft_c2c(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _normalization)
+  , $(bool _forward)));
+  }|]
+
+_fft_c2c_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_fft_c2c_out_ttllb _out _self _dim _normalization _forward =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fft_c2c_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _normalization)
+  , $(bool _forward)));
+  }|]
+
+_validate_compressed_sparse_indices_bttlll
+  :: CBool
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (())
+_validate_compressed_sparse_indices_bttlll _is_crow _compressed_idx _plain_idx _cdim _dim _nnz =
+  [C.throwBlock| void {  (at::_validate_compressed_sparse_indices(
+    $(bool _is_crow)
+  , *$(at::Tensor* _compressed_idx)
+  , *$(at::Tensor* _plain_idx)
+  , $(int64_t _cdim)
+  , $(int64_t _dim)
+  , $(int64_t _nnz)));
+  }|]
+
+_cufft_get_plan_cache_size_l
+  :: Int64
+  -> IO (Int64)
+_cufft_get_plan_cache_size_l _device_index =
+  [C.throwBlock| int64_t { return (at::_cufft_get_plan_cache_size(
+    $(int64_t _device_index)));
+  }|]
+
+_cufft_get_plan_cache_max_size_l
+  :: Int64
+  -> IO (Int64)
+_cufft_get_plan_cache_max_size_l _device_index =
+  [C.throwBlock| int64_t { return (at::_cufft_get_plan_cache_max_size(
+    $(int64_t _device_index)));
+  }|]
+
+_cufft_set_plan_cache_max_size_ll
+  :: Int64
+  -> Int64
+  -> IO (())
+_cufft_set_plan_cache_max_size_ll _device_index _max_size =
+  [C.throwBlock| void {  (at::_cufft_set_plan_cache_max_size(
+    $(int64_t _device_index)
+  , $(int64_t _max_size)));
+  }|]
+
+_cufft_clear_plan_cache_l
+  :: Int64
+  -> IO (())
+_cufft_clear_plan_cache_l _device_index =
+  [C.throwBlock| void {  (at::_cufft_clear_plan_cache(
+    $(int64_t _device_index)));
+  }|]
+
+index_tl
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> IO (Ptr Tensor)
+index_tl _self _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)));
+  }|]
+
+index_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> IO (Ptr Tensor)
+index_out_ttl _out _self _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)));
+  }|]
+
+index_copy_out_ttltt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_copy_out_ttltt _out _self _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+index_copy_tltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_copy_tltt _self _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+index_copy_tntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_copy_tntt _self _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_copy(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+index_put__tltb
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+index_put__tltb _self _indices _values _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_put_(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)));
+  }|]
+
+index_put__tlt
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_put__tlt _self _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_put_(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+index_put_tltb
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+index_put_tltb _self _indices _values _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_put(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)));
+  }|]
+
+index_put_tlt
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_put_tlt _self _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_put(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+_index_put_impl__tltbb
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_index_put_impl__tltbb _self _indices _values _accumulate _unsafe =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl_(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)
+  , $(bool _unsafe)));
+  }|]
+
+_index_put_impl__tltb
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_index_put_impl__tltb _self _indices _values _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl_(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)));
+  }|]
+
+_index_put_impl__tlt
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_index_put_impl__tlt _self _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_index_put_impl_(
+    *$(at::Tensor* _self)
+  , *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+instance_norm_tttttbddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+instance_norm_tttttbddb _input _weight _bias _running_mean _running_var _use_input_stats _momentum _eps _cudnn_enabled =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::instance_norm(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _use_input_stats)
+  , $(double _momentum)
+  , $(double _eps)
+  , $(bool _cudnn_enabled)));
+  }|]
+
+isclose_ttddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+isclose_ttddb _self _other _rtol _atol _equal_nan =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isclose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(double _rtol)
+  , $(double _atol)
+  , $(bool _equal_nan)));
+  }|]
+
+isclose_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+isclose_ttdd _self _other _rtol _atol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isclose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(double _rtol)
+  , $(double _atol)));
+  }|]
+
+isclose_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+isclose_ttd _self _other _rtol =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isclose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(double _rtol)));
+  }|]
+
+isclose_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isclose_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isclose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+isin_out_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_out_tttbb _out _elements _test_elements _assume_unique _invert =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _elements)
+  , *$(at::Tensor* _test_elements)
+  , $(bool _assume_unique)
+  , $(bool _invert)));
+  }|]
+
+isin_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_out_tttb _out _elements _test_elements _assume_unique =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _elements)
+  , *$(at::Tensor* _test_elements)
+  , $(bool _assume_unique)));
+  }|]
+
+isin_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isin_out_ttt _out _elements _test_elements =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _elements)
+  , *$(at::Tensor* _test_elements)));
+  }|]
+
+isin_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_ttbb _elements _test_elements _assume_unique _invert =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Tensor* _elements)
+  , *$(at::Tensor* _test_elements)
+  , $(bool _assume_unique)
+  , $(bool _invert)));
+  }|]
+
+isin_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_ttb _elements _test_elements _assume_unique =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Tensor* _elements)
+  , *$(at::Tensor* _test_elements)
+  , $(bool _assume_unique)));
+  }|]
+
+isin_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isin_tt _elements _test_elements =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Tensor* _elements)
+  , *$(at::Tensor* _test_elements)));
+  }|]
+
+isin_out_ttsbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_out_ttsbb _out _elements _test_element _assume_unique _invert =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _elements)
+  , *$(at::Scalar* _test_element)
+  , $(bool _assume_unique)
+  , $(bool _invert)));
+  }|]
+
+isin_out_ttsb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_out_ttsb _out _elements _test_element _assume_unique =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _elements)
+  , *$(at::Scalar* _test_element)
+  , $(bool _assume_unique)));
+  }|]
+
+isin_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+isin_out_tts _out _elements _test_element =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _elements)
+  , *$(at::Scalar* _test_element)));
+  }|]
+
+isin_tsbb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_tsbb _elements _test_element _assume_unique _invert =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Tensor* _elements)
+  , *$(at::Scalar* _test_element)
+  , $(bool _assume_unique)
+  , $(bool _invert)));
+  }|]
+
+isin_tsb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_tsb _elements _test_element _assume_unique =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Tensor* _elements)
+  , *$(at::Scalar* _test_element)
+  , $(bool _assume_unique)));
+  }|]
+
+isin_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+isin_ts _elements _test_element =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Tensor* _elements)
+  , *$(at::Scalar* _test_element)));
+  }|]
+
+isin_out_tstbb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_out_tstbb _out _element _test_elements _assume_unique _invert =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _element)
+  , *$(at::Tensor* _test_elements)
+  , $(bool _assume_unique)
+  , $(bool _invert)));
+  }|]
+
+isin_out_tstb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_out_tstb _out _element _test_elements _assume_unique =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _element)
+  , *$(at::Tensor* _test_elements)
+  , $(bool _assume_unique)));
+  }|]
+
+isin_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isin_out_tst _out _element _test_elements =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _element)
+  , *$(at::Tensor* _test_elements)));
+  }|]
+
+isin_stbb
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_stbb _element _test_elements _assume_unique _invert =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Scalar* _element)
+  , *$(at::Tensor* _test_elements)
+  , $(bool _assume_unique)
+  , $(bool _invert)));
+  }|]
+
+isin_stb
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+isin_stb _element _test_elements _assume_unique =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Scalar* _element)
+  , *$(at::Tensor* _test_elements)
+  , $(bool _assume_unique)));
+  }|]
+
+isin_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+isin_st _element _test_elements =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isin(
+    *$(at::Scalar* _element)
+  , *$(at::Tensor* _test_elements)));
+  }|]
+
+isnan_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+isnan_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isnan(
+    *$(at::Tensor* _self)));
+  }|]
+
+is_distributed_t
+  :: Ptr Tensor
+  -> IO (CBool)
+is_distributed_t _self =
+  [C.throwBlock| bool { return (at::is_distributed(
+    *$(at::Tensor* _self)));
+  }|]
+
+is_floating_point_t
+  :: Ptr Tensor
+  -> IO (CBool)
+is_floating_point_t _self =
+  [C.throwBlock| bool { return (at::is_floating_point(
+    *$(at::Tensor* _self)));
+  }|]
+
+is_complex_t
+  :: Ptr Tensor
+  -> IO (CBool)
+is_complex_t _self =
+  [C.throwBlock| bool { return (at::is_complex(
+    *$(at::Tensor* _self)));
+  }|]
+
+is_conj_t
+  :: Ptr Tensor
+  -> IO (CBool)
+is_conj_t _self =
+  [C.throwBlock| bool { return (at::is_conj(
+    *$(at::Tensor* _self)));
+  }|]
+
+_is_zerotensor_t
+  :: Ptr Tensor
+  -> IO (CBool)
+_is_zerotensor_t _self =
+  [C.throwBlock| bool { return (at::_is_zerotensor(
+    *$(at::Tensor* _self)));
+  }|]
+
+is_neg_t
+  :: Ptr Tensor
+  -> IO (CBool)
+is_neg_t _self =
+  [C.throwBlock| bool { return (at::is_neg(
+    *$(at::Tensor* _self)));
+  }|]
+
+isreal_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+isreal_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::isreal(
+    *$(at::Tensor* _self)));
+  }|]
+
+is_nonzero_t
+  :: Ptr Tensor
+  -> IO (CBool)
+is_nonzero_t _self =
+  [C.throwBlock| bool { return (at::is_nonzero(
+    *$(at::Tensor* _self)));
+  }|]
+
+is_same_size_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+is_same_size_tt _self _other =
+  [C.throwBlock| bool { return (at::is_same_size(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+is_signed_t
+  :: Ptr Tensor
+  -> IO (CBool)
+is_signed_t _self =
+  [C.throwBlock| bool { return (at::is_signed(
+    *$(at::Tensor* _self)));
+  }|]
+
+is_inference_t
+  :: Ptr Tensor
+  -> IO (CBool)
+is_inference_t _self =
+  [C.throwBlock| bool { return (at::is_inference(
+    *$(at::Tensor* _self)));
+  }|]
+
+kl_div_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+kl_div_ttlb _self _target _reduction _log_target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kl_div(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(bool _log_target)));
+  }|]
+
+kl_div_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+kl_div_ttl _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kl_div(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+kl_div_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+kl_div_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kl_div(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+kron_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+kron_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kron(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+kron_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+kron_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::kron_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+kthvalue_tllb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_tllb _self _k _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+kthvalue_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_tll _self _k _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)));
+  }|]
+
+kthvalue_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_tl _self _k =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)));
+  }|]
+
+kthvalue_out_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttllb _values _indices _self _k _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+kthvalue_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttll _values _indices _self _k _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)));
+  }|]
+
+kthvalue_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttl _values _indices _self _k =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)));
+  }|]
+
+kthvalue_tlnb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_tlnb _self _k _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+kthvalue_tln
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_tln _self _k _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+kthvalue_out_tttlnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttlnb _values _indices _self _k _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+kthvalue_out_tttln
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+kthvalue_out_tttln _values _indices _self _k _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::kthvalue_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+layer_norm_tlttdb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+layer_norm_tlttdb _input _normalized_shape _weight _bias _eps _cudnn_enable =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::layer_norm(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(double _eps)
+  , $(bool _cudnn_enable)));
+  }|]
+
+layer_norm_tlttd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+layer_norm_tlttd _input _normalized_shape _weight _bias _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::layer_norm(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(double _eps)));
+  }|]
+
+layer_norm_tltt
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+layer_norm_tltt _input _normalized_shape _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::layer_norm(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+layer_norm_tlt
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+layer_norm_tlt _input _normalized_shape _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::layer_norm(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+layer_norm_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+layer_norm_tl _input _normalized_shape =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::layer_norm(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)));
+  }|]
+
+native_layer_norm_tlttd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_layer_norm_tlttd _input _normalized_shape _weight _bias _eps =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_layer_norm(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(double _eps)));
+  }|]
+
+native_layer_norm_backward_ttltttta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_layer_norm_backward_ttltttta _grad_out _input _normalized_shape _mean _rstd _weight _bias _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_layer_norm_backward(
+    *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _normalized_shape)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _rstd)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+nan_to_num_tddd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num_tddd _self _nan _posinf _neginf =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num(
+    *$(at::Tensor* _self)
+  , $(double _nan)
+  , $(double _posinf)
+  , $(double _neginf)));
+  }|]
+
+nan_to_num_tdd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num_tdd _self _nan _posinf =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num(
+    *$(at::Tensor* _self)
+  , $(double _nan)
+  , $(double _posinf)));
+  }|]
+
+nan_to_num_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num_td _self _nan =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num(
+    *$(at::Tensor* _self)
+  , $(double _nan)));
+  }|]
+
+nan_to_num_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+nan_to_num_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num(
+    *$(at::Tensor* _self)));
+  }|]
+
+nan_to_num__tddd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num__tddd _self _nan _posinf _neginf =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num_(
+    *$(at::Tensor* _self)
+  , $(double _nan)
+  , $(double _posinf)
+  , $(double _neginf)));
+  }|]
+
+nan_to_num__tdd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num__tdd _self _nan _posinf =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num_(
+    *$(at::Tensor* _self)
+  , $(double _nan)
+  , $(double _posinf)));
+  }|]
+
+nan_to_num__td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num__td _self _nan =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num_(
+    *$(at::Tensor* _self)
+  , $(double _nan)));
+  }|]
+
+nan_to_num__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+nan_to_num__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num_(
+    *$(at::Tensor* _self)));
+  }|]
+
+nan_to_num_out_ttddd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num_out_ttddd _out _self _nan _posinf _neginf =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _nan)
+  , $(double _posinf)
+  , $(double _neginf)));
+  }|]
+
+nan_to_num_out_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num_out_ttdd _out _self _nan _posinf =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _nan)
+  , $(double _posinf)));
+  }|]
+
+nan_to_num_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+nan_to_num_out_ttd _out _self _nan =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _nan)));
+  }|]
+
+nan_to_num_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nan_to_num_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nan_to_num_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+linear_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linear_ttt _input _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linear(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+linear_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linear_tt _input _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linear(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+linear_backward_ttta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+linear_backward_ttta _self _grad_output _weight _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linear_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+linear_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linear_out_tttt _out _input _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linear_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+linear_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+linear_out_ttt _out _input _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linear_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+mkldnn_linear_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_linear_ttt _self _weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_linear(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+mkldnn_linear_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_linear_tt _self _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_linear(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+mkldnn_linear_backward_input_ltt
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_linear_backward_input_ltt _input_size _grad_output _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_linear_backward_input(
+    *$(std::vector<int64_t>* _input_size)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+mkldnn_linear_backward_weights_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mkldnn_linear_backward_weights_tttb _grad_output _input _weight _bias_defined =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mkldnn_linear_backward_weights(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , $(bool _bias_defined)));
+  }|]
+
+mkldnn_linear_backward_ttta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+mkldnn_linear_backward_ttta _self _grad_output _weight _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::mkldnn_linear_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+fbgemm_linear_int8_weight_fp32_activation_ttttsst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fbgemm_linear_int8_weight_fp32_activation_ttttsst _input _weight _packed _col_offsets _weight_scale _weight_zero_point _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fbgemm_linear_int8_weight_fp32_activation(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _packed)
+  , *$(at::Tensor* _col_offsets)
+  , *$(at::Scalar* _weight_scale)
+  , *$(at::Scalar* _weight_zero_point)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+fbgemm_linear_int8_weight_ttttsst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fbgemm_linear_int8_weight_ttttsst _input _weight _packed _col_offsets _weight_scale _weight_zero_point _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fbgemm_linear_int8_weight(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _packed)
+  , *$(at::Tensor* _col_offsets)
+  , *$(at::Scalar* _weight_scale)
+  , *$(at::Scalar* _weight_zero_point)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+fbgemm_linear_quantize_weight_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64)))
+fbgemm_linear_quantize_weight_t _input =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,double,int64_t>* { return new std::tuple<at::Tensor,at::Tensor,double,int64_t>(at::fbgemm_linear_quantize_weight(
+    *$(at::Tensor* _input)));
+  }|]
+
+fbgemm_pack_gemm_matrix_fp16_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fbgemm_pack_gemm_matrix_fp16_t _input =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fbgemm_pack_gemm_matrix_fp16(
+    *$(at::Tensor* _input)));
+  }|]
+
+fbgemm_linear_fp16_weight_fp32_activation_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fbgemm_linear_fp16_weight_fp32_activation_ttt _input _packed_weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fbgemm_linear_fp16_weight_fp32_activation(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _packed_weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+fbgemm_linear_fp16_weight_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fbgemm_linear_fp16_weight_ttt _input _packed_weight _bias =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fbgemm_linear_fp16_weight(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _packed_weight)
+  , *$(at::Tensor* _bias)));
+  }|]
+
+fbgemm_pack_quantized_matrix_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fbgemm_pack_quantized_matrix_t _input =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fbgemm_pack_quantized_matrix(
+    *$(at::Tensor* _input)));
+  }|]
+
+fbgemm_pack_quantized_matrix_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fbgemm_pack_quantized_matrix_tll _input _K _N =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fbgemm_pack_quantized_matrix(
+    *$(at::Tensor* _input)
+  , $(int64_t _K)
+  , $(int64_t _N)));
+  }|]
+
+ldexp_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ldexp_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ldexp(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+ldexp__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ldexp__tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ldexp_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+ldexp_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ldexp_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ldexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+linspace_sslo
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+linspace_sslo _start _end _steps _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+linspace_ssl
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr Tensor)
+linspace_ssl _start _end _steps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)));
+  }|]
+
+linspace_out_tssl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr Tensor)
+linspace_out_tssl _out _start _end _steps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linspace_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)));
+  }|]
+
+log_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log(
+    *$(at::Tensor* _self)));
+  }|]
+
+log__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_(
+    *$(at::Tensor* _self)));
+  }|]
+
+log_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+log_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+log10_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log10_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log10(
+    *$(at::Tensor* _self)));
+  }|]
+
+log10__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log10__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log10_(
+    *$(at::Tensor* _self)));
+  }|]
+
+log10_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+log10_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log10_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+log1p_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log1p_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log1p(
+    *$(at::Tensor* _self)));
+  }|]
+
+log1p__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log1p__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log1p_(
+    *$(at::Tensor* _self)));
+  }|]
+
+log1p_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+log1p_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log1p_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+log2_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log2_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log2(
+    *$(at::Tensor* _self)));
+  }|]
+
+log2__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log2__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log2_(
+    *$(at::Tensor* _self)));
+  }|]
+
+log2_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+log2_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+logaddexp_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logaddexp_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logaddexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+logaddexp_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logaddexp_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logaddexp(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+logaddexp2_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logaddexp2_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logaddexp2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+logaddexp2_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logaddexp2_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logaddexp2(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+xlogy_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+xlogy_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::xlogy(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+xlogy_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+xlogy_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::xlogy(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native3.hs b/src/Torch/Internal/Unmanaged/Native/Native3.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native3.hs
@@ -0,0 +1,3982 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native3 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+xlogy_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+xlogy_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::xlogy(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+xlogy__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+xlogy__tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::xlogy_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+xlogy__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+xlogy__ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::xlogy_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+xlogy_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+xlogy_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::xlogy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+xlogy_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+xlogy_out_tst _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::xlogy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+xlogy_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+xlogy_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::xlogy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+logspace_ssldo
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+logspace_ssldo _start _end _steps _base _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)
+  , $(double _base)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+logspace_ssld
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+logspace_ssld _start _end _steps _base =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)
+  , $(double _base)));
+  }|]
+
+logspace_ssl
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr Tensor)
+logspace_ssl _start _end _steps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)));
+  }|]
+
+logspace_out_tssld
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+logspace_out_tssld _out _start _end _steps _base =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)
+  , $(double _base)));
+  }|]
+
+logspace_out_tssl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr Tensor)
+logspace_out_tssl _out _start _end _steps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)));
+  }|]
+
+log_softmax_tls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+log_softmax_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+log_softmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+log_softmax_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+log_softmax_out_ttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+log_softmax_out_ttls _out _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+log_softmax_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+log_softmax_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+log_softmax_tns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+log_softmax_tns _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+log_softmax_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+log_softmax_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+_log_softmax_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_log_softmax_tlb _self _dim _half_to_float =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_log_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _half_to_float)));
+  }|]
+
+_log_softmax_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_log_softmax_out_ttlb _out _self _dim _half_to_float =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_log_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _half_to_float)));
+  }|]
+
+_log_softmax_backward_data_ttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_log_softmax_backward_data_ttls _grad_output _output _dim _input_dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_log_softmax_backward_data(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , $(int64_t _dim)
+  , $(at::ScalarType _input_dtype)));
+  }|]
+
+_log_softmax_backward_data_out_tttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_log_softmax_backward_data_out_tttls _out _grad_output _output _dim _input_dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_log_softmax_backward_data_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , $(int64_t _dim)
+  , $(at::ScalarType _input_dtype)));
+  }|]
+
+_logcumsumexp_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_logcumsumexp_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_logcumsumexp(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+_logcumsumexp_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_logcumsumexp_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_logcumsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+logcumsumexp_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+logcumsumexp_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logcumsumexp(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+logcumsumexp_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+logcumsumexp_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logcumsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+logcumsumexp_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+logcumsumexp_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logcumsumexp(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+logcumsumexp_out_ttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+logcumsumexp_out_ttn _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logcumsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+logsumexp_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+logsumexp_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+logsumexp_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+logsumexp_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+logsumexp_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+logsumexp_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+logsumexp_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+logsumexp_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+logsumexp_tNb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+logsumexp_tNb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+logsumexp_tN
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+logsumexp_tN _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+logsumexp_out_ttNb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+logsumexp_out_ttNb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+logsumexp_out_ttN
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+logsumexp_out_ttN _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+margin_ranking_loss_tttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+margin_ranking_loss_tttdl _input1 _input2 _target _margin _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::margin_ranking_loss(
+    *$(at::Tensor* _input1)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _target)
+  , $(double _margin)
+  , $(int64_t _reduction)));
+  }|]
+
+margin_ranking_loss_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+margin_ranking_loss_tttd _input1 _input2 _target _margin =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::margin_ranking_loss(
+    *$(at::Tensor* _input1)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _target)
+  , $(double _margin)));
+  }|]
+
+margin_ranking_loss_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+margin_ranking_loss_ttt _input1 _input2 _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::margin_ranking_loss(
+    *$(at::Tensor* _input1)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _target)));
+  }|]
+
+matmul_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+matmul_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::matmul(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+matmul_backward_ttta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+matmul_backward_ttta _grad _self _other _mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::matmul_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::array<bool,2>* _mask)));
+  }|]
+
+matmul_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+matmul_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::matmul_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+matrix_power_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+matrix_power_tl _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::matrix_power(
+    *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+matrix_power_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+matrix_power_out_ttl _out _self _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::matrix_power_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _n)));
+  }|]
+
+matrix_exp_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+matrix_exp_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::matrix_exp(
+    *$(at::Tensor* _self)));
+  }|]
+
+matrix_exp_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+matrix_exp_backward_tt _self _grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::matrix_exp_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad)));
+  }|]
+
+_aminmax_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_aminmax_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_aminmax(
+    *$(at::Tensor* _self)));
+  }|]
+
+_aminmax_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_aminmax_tlb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_aminmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+_aminmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_aminmax_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_aminmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+aminmax_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+aminmax_tlb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::aminmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+aminmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+aminmax_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::aminmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+aminmax_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+aminmax_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::aminmax(
+    *$(at::Tensor* _self)));
+  }|]
+
+aminmax_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+aminmax_out_tttlb _min _max _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::aminmax_out(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+aminmax_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+aminmax_out_tttl _min _max _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::aminmax_out(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+aminmax_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+aminmax_out_ttt _min _max _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::aminmax_out(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_compute_linear_combination_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_compute_linear_combination_tt _input _coefficients =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_compute_linear_combination(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _coefficients)));
+  }|]
+
+_compute_linear_combination_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_compute_linear_combination_out_ttt _out _input _coefficients =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_compute_linear_combination_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _coefficients)));
+  }|]
+
+max_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_tlb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+max_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+max_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_out_tttlb _max _max_values _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_out(
+    *$(at::Tensor* _max)
+  , *$(at::Tensor* _max_values)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+max_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_out_tttl _max _max_values _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_out(
+    *$(at::Tensor* _max)
+  , *$(at::Tensor* _max_values)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+max_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_tnb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+max_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_tn _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+max_out_tttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_out_tttnb _max _max_values _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_out(
+    *$(at::Tensor* _max)
+  , *$(at::Tensor* _max_values)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+max_out_tttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_out_tttn _max _max_values _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_out(
+    *$(at::Tensor* _max)
+  , *$(at::Tensor* _max_values)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+value_selecting_reduction_backward_tltlb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+value_selecting_reduction_backward_tltlb _grad _dim _indices _sizes _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::value_selecting_reduction_backward(
+    *$(at::Tensor* _grad)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _indices)
+  , *$(std::vector<int64_t>* _sizes)
+  , $(bool _keepdim)));
+  }|]
+
+amax_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+amax_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amax(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+amax_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+amax_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amax(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+amax_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+amax_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amax(
+    *$(at::Tensor* _self)));
+  }|]
+
+amax_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+amax_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+amax_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+amax_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+amax_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+amax_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+max_pool1d_with_indices_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool1d_with_indices_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool1d_with_indices_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool1d_with_indices_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tll _self _kernel_size _stride =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool1d_with_indices_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool1d_with_indices_tl _self _kernel_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+max_pool1d_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+max_pool1d_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool1d_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool1d_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool1d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool1d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool1d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool1d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool1d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+max_pool2d_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+max_pool2d_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool2d_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool2d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool2d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+max_pool2d_backward_ttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+max_pool2d_backward_ttllllb _grad_output _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool2d_backward_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_backward_ttllll _grad_output _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool2d_backward_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_backward_ttlll _grad_output _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool2d_backward_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_backward_ttll _grad_output _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool2d_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool2d_backward_ttl _grad_output _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mkldnn_max_pool2d_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+mkldnn_max_pool2d_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_max_pool2d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_max_pool2d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_max_pool2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mkldnn_max_pool2d_backward_tttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_tttllllb _grad_output _output _input _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+mkldnn_max_pool2d_backward_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_tttllll _grad_output _output _input _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_max_pool2d_backward_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_tttlll _grad_output _output _input _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_max_pool2d_backward_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_tttll _grad_output _output _input _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_max_pool2d_backward_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool2d_backward_tttl _grad_output _output _input _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mkldnn_max_pool3d_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+mkldnn_max_pool3d_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_max_pool3d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_max_pool3d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_max_pool3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mkldnn_max_pool3d_backward_tttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_tttllllb _grad_output _output _input _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+mkldnn_max_pool3d_backward_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_tttllll _grad_output _output _input _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_max_pool3d_backward_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_tttlll _grad_output _output _input _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_max_pool3d_backward_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_tttll _grad_output _output _input _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_max_pool3d_backward_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_max_pool3d_backward_tttl _grad_output _output _input _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+quantized_max_pool1d_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+quantized_max_pool1d_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+quantized_max_pool1d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+quantized_max_pool1d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+quantized_max_pool1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool1d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+quantized_max_pool2d_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+quantized_max_pool2d_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+quantized_max_pool2d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+quantized_max_pool2d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+quantized_max_pool2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+quantized_max_pool2d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+max_pool3d_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+max_pool3d_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool3d_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool3d_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool3d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool3d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool3d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool3d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_pool3d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+mean_ts
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+mean_ts _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
+    *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+mean_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+mean_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
+    *$(at::Tensor* _self)));
+  }|]
+
+mean_tlbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+mean_tlbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+mean_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mean_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+mean_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mean_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+mean_out_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+mean_out_ttlbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+mean_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+mean_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+mean_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mean_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+mean_tNbs
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+mean_tNbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+mean_tNb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+mean_tNb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+mean_tN
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+mean_tN _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+mean_out_ttNbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+mean_out_ttNbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+mean_out_ttNb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+mean_out_ttNb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+mean_out_ttN
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+mean_out_ttN _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+nanmean_tlbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+nanmean_tlbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+nanmean_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+nanmean_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanmean_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+nanmean_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+nanmean_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+nanmean_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean(
+    *$(at::Tensor* _self)));
+  }|]
+
+nanmean_out_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+nanmean_out_ttlbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+nanmean_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+nanmean_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanmean_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+nanmean_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+nanmean_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nanmean_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+median_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+median_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::median(
+    *$(at::Tensor* _self)));
+  }|]
+
+median_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+median_tlb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::median(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+median_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+median_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::median(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+median_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+median_out_tttlb _values _indices _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::median_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+median_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+median_out_tttl _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::median_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+median_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+median_tnb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::median(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+median_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+median_tn _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::median(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+median_out_tttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+median_out_tttnb _values _indices _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::median_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+median_out_tttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+median_out_tttn _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::median_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+nanmedian_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+nanmedian_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmedian(
+    *$(at::Tensor* _self)));
+  }|]
+
+nanmedian_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nanmedian_tlb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nanmedian(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanmedian_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nanmedian_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nanmedian(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+nanmedian_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nanmedian_out_tttlb _values _indices _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nanmedian_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanmedian_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nanmedian_out_tttl _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nanmedian_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+nanmedian_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nanmedian_tnb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nanmedian(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanmedian_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nanmedian_tn _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nanmedian(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+nanmedian_out_tttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nanmedian_out_tttnb _values _indices _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nanmedian_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanmedian_out_tttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nanmedian_out_tttn _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nanmedian_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+min_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+min_tlb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::min(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+min_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+min_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::min(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+min_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+min_out_tttlb _min _min_indices _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::min_out(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _min_indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+min_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+min_out_tttl _min _min_indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::min_out(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _min_indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+min_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+min_tnb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::min(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+min_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+min_tn _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::min(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+min_out_tttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+min_out_tttnb _min _min_indices _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::min_out(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _min_indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+min_out_tttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+min_out_tttn _min _min_indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::min_out(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _min_indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+amin_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+amin_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amin(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+amin_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+amin_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amin(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+amin_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+amin_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amin(
+    *$(at::Tensor* _self)));
+  }|]
+
+amin_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+amin_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+amin_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+amin_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+amin_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+amin_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_mps_convolution_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+_mps_convolution_tttllll _self _weight _bias _padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mps_convolution(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+mps_convolution_backward_tttlllla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+mps_convolution_backward_tttlllla _self _grad_output _weight _padding _stride _dilation _groups _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::mps_convolution_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+mkldnn_convolution_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+mkldnn_convolution_tttllll _self _weight _bias _padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_convolution(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+mkldnn_rnn_layer_tttttttbllllbbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+mkldnn_rnn_layer_tttttttbllllbbbb _input _weight0 _weight1 _weight2 _weight3 _hx_ _cx_ _reverse _batch_sizes _mode _hidden_size _num_layers _has_biases _bidirectional _batch_first _train =
+  [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::mkldnn_rnn_layer(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight0)
+  , *$(at::Tensor* _weight1)
+  , *$(at::Tensor* _weight2)
+  , *$(at::Tensor* _weight3)
+  , *$(at::Tensor* _hx_)
+  , *$(at::Tensor* _cx_)
+  , $(bool _reverse)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _num_layers)
+  , $(bool _has_biases)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)
+  , $(bool _train)));
+  }|]
+
+mkldnn_rnn_layer_backward_tttttttttttttblllbbblbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+mkldnn_rnn_layer_backward_tttttttttttttblllbbblbt _input _weight1 _weight2 _weight3 _weight4 _hx_ _cx_tmp _output _hy_ _cy_ _grad_output _grad_hy _grad_cy _reverse _mode _hidden_size _num_layers _has_biases _train _bidirectional _batch_sizes _batch_first _workspace =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::mkldnn_rnn_layer_backward(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight1)
+  , *$(at::Tensor* _weight2)
+  , *$(at::Tensor* _weight3)
+  , *$(at::Tensor* _weight4)
+  , *$(at::Tensor* _hx_)
+  , *$(at::Tensor* _cx_tmp)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _hy_)
+  , *$(at::Tensor* _cy_)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , $(bool _reverse)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _num_layers)
+  , $(bool _has_biases)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , $(bool _batch_first)
+  , *$(at::Tensor* _workspace)));
+  }|]
+
+miopen_batch_norm_tttttbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+miopen_batch_norm_tttttbdd _input _weight _bias _running_mean _running_var _training _exponential_average_factor _epsilon =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::miopen_batch_norm(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _exponential_average_factor)
+  , $(double _epsilon)));
+  }|]
+
+miopen_batch_norm_backward_tttttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+miopen_batch_norm_backward_tttttttd _input _grad_output _weight _running_mean _running_var _save_mean _save_var _epsilon =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::miopen_batch_norm_backward(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_var)
+  , $(double _epsilon)));
+  }|]
+
+miopen_convolution_tttllllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+miopen_convolution_tttllllbb _self _weight _bias _padding _stride _dilation _groups _benchmark _deterministic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_convolution(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)));
+  }|]
+
+miopen_convolution_transpose_tttlllllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+miopen_convolution_transpose_tttlllllbb _self _weight _bias _padding _output_padding _stride _dilation _groups _benchmark _deterministic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_convolution_transpose(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(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)));
+  }|]
+
+miopen_depthwise_convolution_tttllllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+miopen_depthwise_convolution_tttllllbb _self _weight _bias _padding _stride _dilation _groups _benchmark _deterministic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_depthwise_convolution(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , $(bool _benchmark)
+  , $(bool _deterministic)));
+  }|]
+
+miopen_convolution_relu_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+miopen_convolution_relu_tttllll _self _weight _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_convolution_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+miopen_convolution_add_relu_tttstllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+miopen_convolution_add_relu_tttstllll _self _weight _z _alpha _bias _stride _padding _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_convolution_add_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _z)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+miopen_rnn_tllttlllbdbblt
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+miopen_rnn_tllttlllbdbblt _input _weight _weight_stride0 _hx _cx _mode _hidden_size _num_layers _batch_first _dropout _train _bidirectional _batch_sizes _dropout_state =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::miopen_rnn(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _weight)
+  , $(int64_t _weight_stride0)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _cx)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , *$(at::Tensor* _dropout_state)));
+  }|]
+
+miopen_rnn_backward_tlltttttttlllbdbbltta
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,4))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)))
+miopen_rnn_backward_tlltttttttlllbdbbltta _input _weight _weight_stride0 _weight_buf _hx _cx _output _grad_output _grad_hy _grad_cy _mode _hidden_size _num_layers _batch_first _dropout _train _bidirectional _batch_sizes _dropout_state _reserve _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>(at::miopen_rnn_backward(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _weight)
+  , $(int64_t _weight_stride0)
+  , *$(at::Tensor* _weight_buf)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , $(int64_t _mode)
+  , $(int64_t _hidden_size)
+  , $(int64_t _num_layers)
+  , $(bool _batch_first)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , *$(std::vector<int64_t>* _batch_sizes)
+  , *$(at::Tensor* _dropout_state)
+  , *$(at::Tensor* _reserve)
+  , *$(std::array<bool,4>* _output_mask)));
+  }|]
+
+mm_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mm_tt _self _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+mm_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mm_out_ttt _out _self _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+_sparse_mm_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_mm_tt _sparse _dense =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_mm(
+    *$(at::Tensor* _sparse)
+  , *$(at::Tensor* _dense)));
+  }|]
+
+_sparse_mm_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+_sparse_mm_tts _sparse _dense _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_mm(
+    *$(at::Tensor* _sparse)
+  , *$(at::Tensor* _dense)
+  , *$(std::string* _reduce)));
+  }|]
+
+_sparse_sparse_matmul_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_sparse_matmul_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sparse_matmul(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+mode_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_tlb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+mode_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+mode_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode(
+    *$(at::Tensor* _self)));
+  }|]
+
+mode_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_out_tttlb _values _indices _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+mode_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_out_tttl _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+mode_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_out_ttt _values _indices _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)));
+  }|]
+
+mode_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_tnb _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+mode_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_tn _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+mode_out_tttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_out_tttnb _values _indices _self _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+mode_out_tttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+mode_out_tttn _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::mode_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+mul_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mul_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mul(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+mul_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mul_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mul_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+mul_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+mul_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mul(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+multiply_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multiply_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multiply(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+multiply_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multiply_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multiply_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+multiply_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+multiply_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multiply(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+mv_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mv_tt _self _vec =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec)));
+  }|]
+
+mv_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mv_out_ttt _out _self _vec =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _vec)));
+  }|]
+
+mvlgamma_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+mvlgamma_out_ttl _out _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mvlgamma_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _p)));
+  }|]
+
+mvlgamma_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+mvlgamma_tl _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mvlgamma(
+    *$(at::Tensor* _self)
+  , $(int64_t _p)));
+  }|]
+
+narrow_copy_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+narrow_copy_tlll _self _dim _start _length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::narrow_copy(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _length)));
+  }|]
+
+narrow_copy_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+narrow_copy_out_ttlll _out _self _dim _start _length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::narrow_copy_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _length)));
+  }|]
+
+narrow_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+narrow_tlll _self _dim _start _length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::narrow(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(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
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_batch_norm_tttttbdd _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(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _momentum)
+  , $(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)));
+  }|]
+
+_native_batch_norm_legit_tttttbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_native_batch_norm_legit_tttttbdd _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_legit(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(bool _training)
+  , $(double _momentum)
+  , $(double _eps)));
+  }|]
+
+_native_batch_norm_legit_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_legit_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_legit_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)));
+  }|]
+
+_native_batch_norm_legit_tttbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_native_batch_norm_legit_tttbdd _input _weight _bias _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_legit(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(bool _training)
+  , $(double _momentum)
+  , $(double _eps)));
+  }|]
+
+_native_batch_norm_legit_out_ttttttbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_native_batch_norm_legit_out_ttttttbdd _out _save_mean _save_invstd _input _weight _bias _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_legit_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_invstd)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , $(bool _training)
+  , $(double _momentum)
+  , $(double _eps)));
+  }|]
+
+batch_norm_stats_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+batch_norm_stats_td _input _eps =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_stats(
+    *$(at::Tensor* _input)
+  , $(double _eps)));
+  }|]
+
+batch_norm_elemt_tttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+batch_norm_elemt_tttttd _input _weight _bias _mean _invstd _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::batch_norm_elemt(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , $(double _eps)));
+  }|]
+
+batch_norm_elemt_out_ttttttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+batch_norm_elemt_out_ttttttd _out _input _weight _bias _mean _invstd _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::batch_norm_elemt_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , $(double _eps)));
+  }|]
+
+batch_norm_gather_stats_tttttddl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+batch_norm_gather_stats_tttttddl _input _mean _invstd _running_mean _running_var _momentum _eps _count =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_gather_stats(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(double _momentum)
+  , $(double _eps)
+  , $(int64_t _count)));
+  }|]
+
+batch_norm_gather_stats_with_counts_tttttddt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+batch_norm_gather_stats_with_counts_tttttddt _input _mean _invstd _running_mean _running_var _momentum _eps _counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_gather_stats_with_counts(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(double _momentum)
+  , $(double _eps)
+  , *$(at::Tensor* _counts)));
+  }|]
+
+native_batch_norm_backward_tttttttbda
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CDouble
+  -> Ptr (StdArray '(CBool,3))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+native_batch_norm_backward_tttttttbda _grad_out _input _weight _running_mean _running_var _save_mean _save_invstd _train _eps _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_batch_norm_backward(
+    *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , *$(at::Tensor* _save_mean)
+  , *$(at::Tensor* _save_invstd)
+  , $(bool _train)
+  , $(double _eps)
+  , *$(std::array<bool,3>* _output_mask)));
+  }|]
+
+batch_norm_backward_reduce_tttttbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
+batch_norm_backward_reduce_tttttbbb _grad_out _input _mean _invstd _weight _input_g _weight_g _bias_g =
+  [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::batch_norm_backward_reduce(
+    *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , *$(at::Tensor* _weight)
+  , $(bool _input_g)
+  , $(bool _weight_g)
+  , $(bool _bias_g)));
+  }|]
+
+batch_norm_backward_elemt_tttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+batch_norm_backward_elemt_tttttttt _grad_out _input _mean _invstd _weight _mean_dy _mean_dy_xmu _count =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::batch_norm_backward_elemt(
+    *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _invstd)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _mean_dy)
+  , *$(at::Tensor* _mean_dy_xmu)
+  , *$(at::Tensor* _count)));
+  }|]
+
+batch_norm_update_stats_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+batch_norm_update_stats_tttd _input _running_mean _running_var _momentum =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_update_stats(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _running_mean)
+  , *$(at::Tensor* _running_var)
+  , $(double _momentum)));
+  }|]
+
+is_vulkan_available
+  :: IO (CBool)
+is_vulkan_available  =
+  [C.throwBlock| bool { return (at::is_vulkan_available(
+    ));
+  }|]
+
+_nnpack_available
+  :: IO (CBool)
+_nnpack_available  =
+  [C.throwBlock| bool { return (at::_nnpack_available(
+    ));
+  }|]
+
+_nnpack_spatial_convolution_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_nnpack_spatial_convolution_tttll _input _weight _bias _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nnpack_spatial_convolution(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+_nnpack_spatial_convolution_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_nnpack_spatial_convolution_tttl _input _weight _bias _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nnpack_spatial_convolution(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _weight)
+  , *$(at::Tensor* _bias)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+ones_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+ones_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+ones_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+ones_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+ones_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+ones_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+ones_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+ones_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+ones_out_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+ones_out_tl _out _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+ones_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+ones_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+ones_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+ones_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+pairwise_distance_ttddb _x1 _x2 _p _eps _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pairwise_distance(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)
+  , $(double _eps)
+  , $(bool _keepdim)));
+  }|]
+
+pairwise_distance_ttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+pairwise_distance_ttdd _x1 _x2 _p _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pairwise_distance(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)
+  , $(double _eps)));
+  }|]
+
+pairwise_distance_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+pairwise_distance_ttd _x1 _x2 _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pairwise_distance(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)));
+  }|]
+
+pairwise_distance_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+pairwise_distance_tt _x1 _x2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pairwise_distance(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)));
+  }|]
+
+cdist_ttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+cdist_ttdl _x1 _x2 _p _compute_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cdist(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)
+  , $(int64_t _compute_mode)));
+  }|]
+
+cdist_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+cdist_ttd _x1 _x2 _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cdist(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)));
+  }|]
+
+cdist_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cdist_tt _x1 _x2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cdist(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)));
+  }|]
+
+_euclidean_dist_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_euclidean_dist_tt _x1 _x2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_euclidean_dist(
+    *$(at::Tensor* _x1)
+  , *$(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
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_cdist_backward_tttdt _grad _x1 _x2 _p _cdist =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cdist_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(double _p)
+  , *$(at::Tensor* _cdist)));
+  }|]
+
+pdist_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+pdist_td _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pdist(
+    *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+pdist_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+pdist_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pdist(
+    *$(at::Tensor* _self)));
+  }|]
+
+_pdist_forward_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+_pdist_forward_td _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pdist_forward(
+    *$(at::Tensor* _self)
+  , $(double _p)));
+  }|]
+
+_pdist_forward_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_pdist_forward_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pdist_forward(
+    *$(at::Tensor* _self)));
+  }|]
+
+_pdist_backward_ttdt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_pdist_backward_ttdt _grad _self _p _pdist =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pdist_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , $(double _p)
+  , *$(at::Tensor* _pdist)));
+  }|]
+
+cosine_similarity_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+cosine_similarity_ttld _x1 _x2 _dim _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosine_similarity(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(int64_t _dim)
+  , $(double _eps)));
+  }|]
+
+cosine_similarity_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cosine_similarity_ttl _x1 _x2 _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosine_similarity(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)
+  , $(int64_t _dim)));
+  }|]
+
+cosine_similarity_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cosine_similarity_tt _x1 _x2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cosine_similarity(
+    *$(at::Tensor* _x1)
+  , *$(at::Tensor* _x2)));
+  }|]
+
+permute_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+permute_tl _self _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::permute(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+movedim_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+movedim_tll _self _source _destination =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::movedim(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _source)
+  , *$(std::vector<int64_t>* _destination)));
+  }|]
+
+moveaxis_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+moveaxis_tll _self _source _destination =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::moveaxis(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _source)
+  , *$(std::vector<int64_t>* _destination)));
+  }|]
+
+adjoint_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+adjoint_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adjoint(
+    *$(at::Tensor* _self)));
+  }|]
+
+pixel_shuffle_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+pixel_shuffle_tl _self _upscale_factor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pixel_shuffle(
+    *$(at::Tensor* _self)
+  , $(int64_t _upscale_factor)));
+  }|]
+
+pixel_unshuffle_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+pixel_unshuffle_tl _self _downscale_factor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pixel_unshuffle(
+    *$(at::Tensor* _self)
+  , $(int64_t _downscale_factor)));
+  }|]
+
+channel_shuffle_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+channel_shuffle_tl _self _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::channel_shuffle(
+    *$(at::Tensor* _self)
+  , $(int64_t _groups)));
+  }|]
+
+native_channel_shuffle_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+native_channel_shuffle_tl _self _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_channel_shuffle(
+    *$(at::Tensor* _self)
+  , $(int64_t _groups)));
+  }|]
+
+_pin_memory_tD
+  :: Ptr Tensor
+  -> DeviceType
+  -> IO (Ptr Tensor)
+_pin_memory_tD _self _device =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pin_memory(
+    *$(at::Tensor* _self)
+  , $(at::DeviceType _device)));
+  }|]
+
+_pin_memory_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_pin_memory_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pin_memory(
+    *$(at::Tensor* _self)));
+  }|]
+
+pinverse_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+pinverse_td _self _rcond =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pinverse(
+    *$(at::Tensor* _self)
+  , $(double _rcond)));
+  }|]
+
+pinverse_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+pinverse_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pinverse(
+    *$(at::Tensor* _self)));
+  }|]
+
+poisson_nll_loss_ttbbdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+poisson_nll_loss_ttbbdl _input _target _log_input _full _eps _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::poisson_nll_loss(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _target)
+  , $(bool _log_input)
+  , $(bool _full)
+  , $(double _eps)
+  , $(int64_t _reduction)));
+  }|]
+
+rad2deg_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rad2deg_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rad2deg(
+    *$(at::Tensor* _self)));
+  }|]
+
+rad2deg__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rad2deg__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rad2deg_(
+    *$(at::Tensor* _self)));
+  }|]
+
+rad2deg_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rad2deg_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rad2deg_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+deg2rad_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+deg2rad_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::deg2rad(
+    *$(at::Tensor* _self)));
+  }|]
+
+deg2rad__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+deg2rad__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::deg2rad_(
+    *$(at::Tensor* _self)));
+  }|]
+
+deg2rad_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+deg2rad_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::deg2rad_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+scalar_tensor_so
+  :: Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+scalar_tensor_so _s _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scalar_tensor(
+    *$(at::Scalar* _s)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+scalar_tensor_s
+  :: Ptr Scalar
+  -> IO (Ptr Tensor)
+scalar_tensor_s _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scalar_tensor(
+    *$(at::Scalar* _s)));
+  }|]
+
+rand_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native4.hs b/src/Torch/Internal/Unmanaged/Native/Native4.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native4.hs
@@ -0,0 +1,3210 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native4 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+rand_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+rand_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+rand_lGNo
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_lGNo _size _generator _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+rand_lGN
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+rand_lGN _size _generator _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+rand_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+rand_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+rand_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+rand_lGo
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_lGo _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+rand_lG
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+rand_lG _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+rand_out_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+rand_out_tl _out _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+rand_out_tlG
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+rand_out_tlG _out _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+rand_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+rand_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+rand_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_llo _high _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint(
+    $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randint_ll
+  :: Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+randint_ll _high _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint(
+    $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+randint_llGo
+  :: Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_llGo _high _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint(
+    $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randint_llG
+  :: Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randint_llG _high _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint(
+    $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randint_lllo
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_lllo _low _high _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint(
+    $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randint_lll
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+randint_lll _low _high _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint(
+    $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+randint_lllGo
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_lllGo _low _high _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint(
+    $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randint_lllG
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randint_lllG _low _high _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint(
+    $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randint_out_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+randint_out_tll _out _high _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+randint_out_tllG
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randint_out_tllG _out _high _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randint_out_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+randint_out_tlll _out _low _high _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+randint_out_tlllG
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randint_out_tlllG _out _low _high _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randint_like_tloM
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+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_tlo
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_like_tlo _self _high _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like(
+    *$(at::Tensor* _self)
+  , $(int64_t _high)
+  , *$(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(at::randint_like(
+    *$(at::Tensor* _self)
+  , $(int64_t _high)));
+  }|]
+
+randint_like_tlloM
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+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_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)));
+  }|]
+
+randint_like_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+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)));
+  }|]
+
+randn_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randn_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+randn_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+randn_lGo
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_lGo _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randn_lG
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randn_lG _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randn_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randn_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+randn_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+randn_lGNo
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_lGNo _size _generator _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randn_lGN
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+randn_lGN _size _generator _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+randn_out_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+randn_out_tl _out _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+randn_out_tlG
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randn_out_tlG _out _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randn_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+randn_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+randn_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> IO (Ptr Tensor)
+randperm_lo _n _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randperm(
+    $(int64_t _n)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randperm_l
+  :: Int64
+  -> IO (Ptr Tensor)
+randperm_l _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randperm(
+    $(int64_t _n)));
+  }|]
+
+randperm_lGo
+  :: Int64
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randperm_lGo _n _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randperm(
+    $(int64_t _n)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randperm_lG
+  :: Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randperm_lG _n _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randperm(
+    $(int64_t _n)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randperm_out_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+randperm_out_tl _out _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randperm_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)));
+  }|]
+
+randperm_out_tlG
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randperm_out_tlG _out _n _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randperm_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)
+  , *$(at::Generator* _generator)));
+  }|]
+
+range_ssso
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+range_ssso _start _end _step _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::range(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+range_sss
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+range_sss _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::range(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)));
+  }|]
+
+range_out_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+range_out_tss _out _start _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::range_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)));
+  }|]
+
+range_out_tsss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+range_out_tsss _out _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::range_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)));
+  }|]
+
+ravel_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+ravel_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ravel(
+    *$(at::Tensor* _self)));
+  }|]
+
+reciprocal_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+reciprocal_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reciprocal(
+    *$(at::Tensor* _self)));
+  }|]
+
+reciprocal__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+reciprocal__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reciprocal_(
+    *$(at::Tensor* _self)));
+  }|]
+
+reciprocal_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+reciprocal_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reciprocal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+neg_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+neg_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::neg(
+    *$(at::Tensor* _self)));
+  }|]
+
+neg__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+neg__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::neg_(
+    *$(at::Tensor* _self)));
+  }|]
+
+neg_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+neg_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::neg_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+negative_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+negative_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::negative(
+    *$(at::Tensor* _self)));
+  }|]
+
+negative__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+negative__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::negative_(
+    *$(at::Tensor* _self)));
+  }|]
+
+negative_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+negative_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::negative_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+repeat_interleave_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+repeat_interleave_tl _repeats _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave(
+    *$(at::Tensor* _repeats)
+  , $(int64_t _output_size)));
+  }|]
+
+repeat_interleave_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+repeat_interleave_t _repeats =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave(
+    *$(at::Tensor* _repeats)));
+  }|]
+
+repeat_interleave_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+repeat_interleave_ttll _self _repeats _dim _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _repeats)
+  , $(int64_t _dim)
+  , $(int64_t _output_size)));
+  }|]
+
+repeat_interleave_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+repeat_interleave_ttl _self _repeats _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _repeats)
+  , $(int64_t _dim)));
+  }|]
+
+repeat_interleave_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+repeat_interleave_tt _self _repeats =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _repeats)));
+  }|]
+
+repeat_interleave_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+repeat_interleave_tlll _self _repeats _dim _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave(
+    *$(at::Tensor* _self)
+  , $(int64_t _repeats)
+  , $(int64_t _dim)
+  , $(int64_t _output_size)));
+  }|]
+
+repeat_interleave_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+repeat_interleave_tll _self _repeats _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave(
+    *$(at::Tensor* _self)
+  , $(int64_t _repeats)
+  , $(int64_t _dim)));
+  }|]
+
+reshape_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reshape_tl _self _shape =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reshape(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _shape)));
+  }|]
+
+_reshape_copy_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_reshape_copy_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_reshape_copy(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_reshape_alias_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_reshape_alias_tll _self _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_reshape_alias(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+_mkldnn_reshape_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_mkldnn_reshape_tl _self _shape =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mkldnn_reshape(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _shape)));
+  }|]
+
+round_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+round_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::round(
+    *$(at::Tensor* _self)));
+  }|]
+
+round__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+round__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::round_(
+    *$(at::Tensor* _self)));
+  }|]
+
+round_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+round_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::round_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+round_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+round_tl _self _decimals =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::round(
+    *$(at::Tensor* _self)
+  , $(int64_t _decimals)));
+  }|]
+
+round__tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+round__tl _self _decimals =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::round_(
+    *$(at::Tensor* _self)
+  , $(int64_t _decimals)));
+  }|]
+
+round_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+round_out_ttl _out _self _decimals =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::round_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _decimals)));
+  }|]
+
+rrelu_tssbG
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+rrelu_tssbG _self _lower _upper _training _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)
+  , *$(at::Generator* _generator)));
+  }|]
+
+rrelu_tssb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+rrelu_tssb _self _lower _upper _training =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)));
+  }|]
+
+rrelu_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu_tss _self _lower _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)));
+  }|]
+
+rrelu_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu_ts _self _lower =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lower)));
+  }|]
+
+rrelu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rrelu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu(
+    *$(at::Tensor* _self)));
+  }|]
+
+rrelu__tssbG
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+rrelu__tssbG _self _lower _upper _training _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)
+  , *$(at::Generator* _generator)));
+  }|]
+
+rrelu__tssb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+rrelu__tssb _self _lower _upper _training =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)));
+  }|]
+
+rrelu__tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu__tss _self _lower _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)));
+  }|]
+
+rrelu__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu__ts _self _lower =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lower)));
+  }|]
+
+rrelu__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rrelu__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_(
+    *$(at::Tensor* _self)));
+  }|]
+
+relu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+relu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::relu(
+    *$(at::Tensor* _self)));
+  }|]
+
+relu__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+relu__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::relu_(
+    *$(at::Tensor* _self)));
+  }|]
+
+relu6_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+relu6_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::relu6(
+    *$(at::Tensor* _self)));
+  }|]
+
+relu6__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+relu6__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::relu6_(
+    *$(at::Tensor* _self)));
+  }|]
+
+prelu_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+prelu_tt _self _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prelu(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+_prelu_kernel_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_prelu_kernel_tt _self _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_prelu_kernel(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+_prelu_kernel_backward_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_prelu_kernel_backward_ttt _grad_output _self _weight =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_prelu_kernel_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+gelu_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+gelu_out_tts _out _self _approximate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::string* _approximate)));
+  }|]
+
+gelu_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gelu_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+gelu__ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+gelu__ts _self _approximate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu_(
+    *$(at::Tensor* _self)
+  , *$(std::string* _approximate)));
+  }|]
+
+gelu__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+gelu__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu_(
+    *$(at::Tensor* _self)));
+  }|]
+
+gelu_ts
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+gelu_ts _self _approximate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu(
+    *$(at::Tensor* _self)
+  , *$(std::string* _approximate)));
+  }|]
+
+gelu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+gelu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu(
+    *$(at::Tensor* _self)));
+  }|]
+
+gelu_backward_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+gelu_backward_out_ttts _grad_input _grad_output _self _approximate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::string* _approximate)));
+  }|]
+
+gelu_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gelu_backward_out_ttt _grad_input _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+gelu_backward_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+gelu_backward_tts _grad_output _self _approximate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::string* _approximate)));
+  }|]
+
+gelu_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gelu_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gelu_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+infinitely_differentiable_gelu_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+infinitely_differentiable_gelu_backward_tt _grad _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::infinitely_differentiable_gelu_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)));
+  }|]
+
+hardshrink_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardshrink_out_tts _out _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardshrink_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+hardshrink_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hardshrink_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardshrink_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+hardshrink_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardshrink_ts _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardshrink(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+hardshrink_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+hardshrink_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardshrink(
+    *$(at::Tensor* _self)));
+  }|]
+
+hardshrink_backward_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardshrink_backward_out_ttts _grad_input _grad_out _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardshrink_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+hardshrink_backward_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardshrink_backward_tts _grad_out _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardshrink_backward(
+    *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+rsqrt_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rsqrt_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsqrt(
+    *$(at::Tensor* _self)));
+  }|]
+
+rsqrt__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rsqrt__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsqrt_(
+    *$(at::Tensor* _self)));
+  }|]
+
+rsqrt_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rsqrt_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsqrt_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+select_tnl
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Int64
+  -> IO (Ptr Tensor)
+select_tnl _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(int64_t _index)));
+  }|]
+
+select_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+select_tll _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+select_backward_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+select_backward_tlll _grad_output _input_sizes _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _input_sizes)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+_nested_select_backward_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_nested_select_backward_ttll _grad_output _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_select_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+selu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+selu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::selu(
+    *$(at::Tensor* _self)));
+  }|]
+
+selu__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+selu__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::selu_(
+    *$(at::Tensor* _self)));
+  }|]
+
+celu_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+celu_ts _self _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::celu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+celu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+celu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::celu(
+    *$(at::Tensor* _self)));
+  }|]
+
+celu__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+celu__ts _self _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::celu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+celu__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+celu__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::celu_(
+    *$(at::Tensor* _self)));
+  }|]
+
+silu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+silu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::silu(
+    *$(at::Tensor* _self)));
+  }|]
+
+silu__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+silu__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::silu_(
+    *$(at::Tensor* _self)));
+  }|]
+
+silu_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+silu_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::silu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+silu_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+silu_backward_out_ttt _grad_input _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::silu_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+silu_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+silu_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::silu_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+mish_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+mish_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mish(
+    *$(at::Tensor* _self)));
+  }|]
+
+mish__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+mish__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mish_(
+    *$(at::Tensor* _self)));
+  }|]
+
+mish_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mish_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mish_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+mish_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mish_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mish_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+sigmoid_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sigmoid_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sigmoid(
+    *$(at::Tensor* _self)));
+  }|]
+
+sigmoid__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sigmoid__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sigmoid_(
+    *$(at::Tensor* _self)));
+  }|]
+
+sigmoid_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sigmoid_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sigmoid_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+logit_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+logit_td _self _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit(
+    *$(at::Tensor* _self)
+  , $(double _eps)));
+  }|]
+
+logit_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+logit_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit(
+    *$(at::Tensor* _self)));
+  }|]
+
+logit__td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+logit__td _self _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit_(
+    *$(at::Tensor* _self)
+  , $(double _eps)));
+  }|]
+
+logit__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+logit__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit_(
+    *$(at::Tensor* _self)));
+  }|]
+
+logit_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+logit_out_ttd _out _self _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _eps)));
+  }|]
+
+logit_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+logit_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logit_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+sin_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sin_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sin(
+    *$(at::Tensor* _self)));
+  }|]
+
+sin__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sin__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sin_(
+    *$(at::Tensor* _self)));
+  }|]
+
+sin_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sin_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+sinc_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sinc_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sinc(
+    *$(at::Tensor* _self)));
+  }|]
+
+sinc__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sinc__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sinc_(
+    *$(at::Tensor* _self)));
+  }|]
+
+sinc_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sinc_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sinc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+sinh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sinh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sinh(
+    *$(at::Tensor* _self)));
+  }|]
+
+sinh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sinh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sinh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+sinh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sinh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sinh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+detach_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+detach_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::detach(
+    *$(at::Tensor* _self)));
+  }|]
+
+detach__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+detach__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::detach_(
+    *$(at::Tensor* _self)));
+  }|]
+
+size_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Int64)
+size_tl _self _dim =
+  [C.throwBlock| int64_t { return (at::size(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+size_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Int64)
+size_tn _self _dim =
+  [C.throwBlock| int64_t { return (at::size(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+slice_tllll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_tllll _self _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+slice_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_tlll _self _dim _start _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)));
+  }|]
+
+slice_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_tll _self _dim _start =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(int64_t _start)));
+  }|]
+
+slice_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+slice_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+slice_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice(
+    *$(at::Tensor* _self)));
+  }|]
+
+slice_backward_tlllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_backward_tlllll _grad_output _input_sizes _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(std::vector<int64_t>* _input_sizes)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+slice_scatter_ttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_scatter_ttllll _self _src _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+slice_scatter_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_scatter_ttlll _self _src _dim _start _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)));
+  }|]
+
+slice_scatter_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_scatter_ttll _self _src _dim _start =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _start)));
+  }|]
+
+slice_scatter_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+slice_scatter_ttl _self _src _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)));
+  }|]
+
+slice_scatter_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+slice_scatter_tt _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+select_scatter_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+select_scatter_ttll _self _src _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+diagonal_scatter_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_scatter_ttlll _self _src _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+diagonal_scatter_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_scatter_ttll _self _src _offset _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)));
+  }|]
+
+diagonal_scatter_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diagonal_scatter_ttl _self _src _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(int64_t _offset)));
+  }|]
+
+diagonal_scatter_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diagonal_scatter_tt _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+as_strided_scatter_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+as_strided_scatter_ttlll _self _src _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+as_strided_scatter_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+as_strided_scatter_ttll _self _src _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+smm_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+smm_tt _self _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+softmax_tls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+softmax_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+softmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+softmax_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+softmax_out_ttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+softmax_out_ttls _out _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+softmax_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+softmax_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+softmax_tns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+softmax_tns _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+softmax_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+softmax_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+_softmax_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_softmax_tlb _self _dim _half_to_float =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _half_to_float)));
+  }|]
+
+_softmax_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_softmax_out_ttlb _out _self _dim _half_to_float =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_softmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _half_to_float)));
+  }|]
+
+_softmax_backward_data_ttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_softmax_backward_data_ttls _grad_output _output _dim _input_dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_softmax_backward_data(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , $(int64_t _dim)
+  , $(at::ScalarType _input_dtype)));
+  }|]
+
+_softmax_backward_data_out_tttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_softmax_backward_data_out_tttls _grad_input _grad_output _output _dim _input_dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_softmax_backward_data_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , $(int64_t _dim)
+  , $(at::ScalarType _input_dtype)));
+  }|]
+
+unsafe_split_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+unsafe_split_tll _self _split_size _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unsafe_split(
+    *$(at::Tensor* _self)
+  , $(int64_t _split_size)
+  , $(int64_t _dim)));
+  }|]
+
+unsafe_split_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+unsafe_split_tl _self _split_size =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unsafe_split(
+    *$(at::Tensor* _self)
+  , $(int64_t _split_size)));
+  }|]
+
+split_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+split_tll _self _split_size _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split(
+    *$(at::Tensor* _self)
+  , $(int64_t _split_size)
+  , $(int64_t _dim)));
+  }|]
+
+split_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+split_tl _self _split_size =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split(
+    *$(at::Tensor* _self)
+  , $(int64_t _split_size)));
+  }|]
+
+unsafe_split_with_sizes_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr TensorList)
+unsafe_split_with_sizes_tll _self _split_sizes _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unsafe_split_with_sizes(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)
+  , $(int64_t _dim)));
+  }|]
+
+unsafe_split_with_sizes_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr TensorList)
+unsafe_split_with_sizes_tl _self _split_sizes =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unsafe_split_with_sizes(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)));
+  }|]
+
+split_with_sizes_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr TensorList)
+split_with_sizes_tll _self _split_sizes _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_with_sizes(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)
+  , $(int64_t _dim)));
+  }|]
+
+split_with_sizes_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr TensorList)
+split_with_sizes_tl _self _split_sizes =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_with_sizes(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _split_sizes)));
+  }|]
+
+hsplit_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+hsplit_tl _self _sections =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::hsplit(
+    *$(at::Tensor* _self)
+  , $(int64_t _sections)));
+  }|]
+
+vsplit_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+vsplit_tl _self _sections =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::vsplit(
+    *$(at::Tensor* _self)
+  , $(int64_t _sections)));
+  }|]
+
+dsplit_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+dsplit_tl _self _sections =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::dsplit(
+    *$(at::Tensor* _self)
+  , $(int64_t _sections)));
+  }|]
+
+squeeze_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+squeeze_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::squeeze(
+    *$(at::Tensor* _self)));
+  }|]
+
+squeeze_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+squeeze_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::squeeze(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+squeeze_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+squeeze_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::squeeze(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+sspaddmm_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sspaddmm_tttss _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sspaddmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+sspaddmm_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sspaddmm_ttts _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sspaddmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+sspaddmm_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sspaddmm_ttt _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sspaddmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+sspaddmm_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sspaddmm_out_ttttss _out _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sspaddmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+sspaddmm_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sspaddmm_out_tttts _out _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sspaddmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+sspaddmm_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sspaddmm_out_tttt _out _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sspaddmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+stack_ll
+  :: Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+stack_ll _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stack(
+    *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+stack_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+stack_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stack(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+stack_out_tll
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+stack_out_tll _out _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+stack_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+stack_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+_stack_ll
+  :: Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+_stack_ll _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_stack(
+    *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+_stack_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+_stack_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_stack(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+_stack_out_tll
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Int64
+  -> IO (Ptr Tensor)
+_stack_out_tll _out _tensors _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_stack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)
+  , $(int64_t _dim)));
+  }|]
+
+_stack_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+_stack_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_stack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+hstack_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+hstack_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hstack(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+hstack_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+hstack_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hstack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+vstack_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+vstack_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::vstack(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+vstack_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+vstack_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::vstack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+dstack_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+dstack_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dstack(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+dstack_out_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+dstack_out_tl _out _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dstack_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+stft_tllltbbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+stft_tllltbbb _self _n_fft _hop_length _win_length _window _normalized _onesided _return_complex =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _normalized)
+  , $(bool _onesided)
+  , $(bool _return_complex)));
+  }|]
+
+stft_tllltbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+stft_tllltbb _self _n_fft _hop_length _win_length _window _normalized _onesided =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _normalized)
+  , $(bool _onesided)));
+  }|]
+
+-- stft_tllltb
+--   :: Ptr Tensor
+--   -> Int64
+--   -> Int64
+--   -> Int64
+--   -> Ptr Tensor
+--   -> CBool
+--   -> IO (Ptr Tensor)
+-- stft_tllltb _self _n_fft _hop_length _win_length _window _normalized =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+--     *$(at::Tensor* _self)
+--   , $(int64_t _n_fft)
+--   , $(int64_t _hop_length)
+--   , $(int64_t _win_length)
+--   , *$(at::Tensor* _window)
+--   , $(bool _normalized)));
+--   }|]
+
+stft_tlllt
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+stft_tlllt _self _n_fft _hop_length _win_length _window =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)));
+  }|]
+
+stft_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+stft_tlll _self _n_fft _hop_length _win_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)));
+  }|]
+
+stft_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+stft_tll _self _n_fft _hop_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)));
+  }|]
+
+stft_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+stft_tl _self _n_fft =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)));
+  }|]
+
+stft_tllltbsbbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr StdString
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+stft_tllltbsbbb _self _n_fft _hop_length _win_length _window _center _pad_mode _normalized _onesided _return_complex =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , *$(std::string* _pad_mode)
+  , $(bool _normalized)
+  , $(bool _onesided)
+  , $(bool _return_complex)));
+  }|]
+
+stft_tllltbsbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr StdString
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+stft_tllltbsbb _self _n_fft _hop_length _win_length _window _center _pad_mode _normalized _onesided =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , *$(std::string* _pad_mode)
+  , $(bool _normalized)
+  , $(bool _onesided)));
+  }|]
+
+stft_tllltbsb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+stft_tllltbsb _self _n_fft _hop_length _win_length _window _center _pad_mode _normalized =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , *$(std::string* _pad_mode)
+  , $(bool _normalized)));
+  }|]
+
+stft_tllltbs
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+stft_tllltbs _self _n_fft _hop_length _win_length _window _center _pad_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::stft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , *$(std::string* _pad_mode)));
+  }|]
+
+istft_tllltbbblb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+istft_tllltbbblb _self _n_fft _hop_length _win_length _window _center _normalized _onesided _length _return_complex =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , $(bool _normalized)
+  , $(bool _onesided)
+  , $(int64_t _length)
+  , $(bool _return_complex)));
+  }|]
+
+istft_tllltbbbl
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+istft_tllltbbbl _self _n_fft _hop_length _win_length _window _center _normalized _onesided _length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , $(bool _normalized)
+  , $(bool _onesided)
+  , $(int64_t _length)));
+  }|]
+
+istft_tllltbbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+istft_tllltbbb _self _n_fft _hop_length _win_length _window _center _normalized _onesided =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , $(bool _normalized)
+  , $(bool _onesided)));
+  }|]
+
+istft_tllltbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+istft_tllltbb _self _n_fft _hop_length _win_length _window _center _normalized =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , $(bool _normalized)));
+  }|]
+
+istft_tllltb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+istft_tllltb _self _n_fft _hop_length _win_length _window _center =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)));
+  }|]
+
+istft_tlllt
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+istft_tlllt _self _n_fft _hop_length _win_length _window =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)));
+  }|]
+
+istft_tlll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+istft_tlll _self _n_fft _hop_length _win_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)));
+  }|]
+
+istft_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+istft_tll _self _n_fft _hop_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)
+  , $(int64_t _hop_length)));
+  }|]
+
+istft_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+istft_tl _self _n_fft =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::istft(
+    *$(at::Tensor* _self)
+  , $(int64_t _n_fft)));
+  }|]
+
+stride_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Int64)
+stride_tl _self _dim =
+  [C.throwBlock| int64_t { return (at::stride(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+stride_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Int64)
+stride_tn _self _dim =
+  [C.throwBlock| int64_t { return (at::stride(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+sum_ts
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+sum_ts _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum(
+    *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+sum_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sum_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum(
+    *$(at::Tensor* _self)));
+  }|]
+
+sum_tlbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+sum_tlbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+sum_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+sum_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+sum_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+sum_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+sum_tNbs
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+sum_tNbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+sum_tNb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+sum_tNb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+sum_tN
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+sum_tN _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+sum_out_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+sum_out_ttlbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+sum_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+sum_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+sum_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+sum_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+sum_out_ttNbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+sum_out_ttNbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+sum_out_ttNb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+sum_out_ttNb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+sum_out_ttN
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+sum_out_ttN _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+_nested_sum_backward_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_nested_sum_backward_ttlb _grad _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_sum_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+_nested_sum_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_nested_sum_backward_ttl _grad _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_sum_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+nansum_tlbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+nansum_tlbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nansum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+nansum_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+nansum_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nansum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nansum_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+nansum_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nansum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+nansum_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+nansum_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nansum(
+    *$(at::Tensor* _self)));
+  }|]
+
+nansum_out_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+nansum_out_ttlbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nansum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+nansum_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+nansum_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nansum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nansum_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+nansum_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nansum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+nansum_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nansum_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nansum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+sqrt_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sqrt_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sqrt(
+    *$(at::Tensor* _self)));
+  }|]
+
+sqrt__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sqrt__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sqrt_(
+    *$(at::Tensor* _self)));
+  }|]
+
+sqrt_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sqrt_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sqrt_out(
+    *$(at::Tensor* _out)
+  , *$(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)));
+  }|]
+
+square_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+square_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::square_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+std_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+std_tb _self _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , $(bool _unbiased)));
+  }|]
+
+std_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+std_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)));
+  }|]
+
+std_tlbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+std_tlbb _self _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native5.hs b/src/Torch/Internal/Unmanaged/Native/Native5.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native5.hs
@@ -0,0 +1,3252 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native5 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+std_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+std_tlb _self _dim _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+std_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+std_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+std_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+std_tllb _self _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+std_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+std_tll _self _dim _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+-- std_t
+--   :: Ptr Tensor
+--   -> IO (Ptr Tensor)
+-- std_t _self =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+--     *$(at::Tensor* _self)));
+--   }|]
+
+std_mean_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tb _self _unbiased =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , $(bool _unbiased)));
+  }|]
+
+std_mean_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)));
+  }|]
+
+std_mean_tlbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tlbb _self _dim _unbiased _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+std_mean_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tlb _self _dim _unbiased =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+std_mean_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+std_mean_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tllb _self _dim _correction _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+std_mean_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tll _self _dim _correction =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+std_mean_tNbb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tNbb _self _dim _unbiased _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+std_mean_tNb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tNb _self _dim _unbiased =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+std_mean_tN
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tN _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+std_mean_tNlb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tNlb _self _dim _correction _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+std_mean_tNl
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+std_mean_tNl _self _dim _correction =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+std_out_ttlbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+std_out_ttlbb _out _self _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+std_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+std_out_ttlb _out _self _dim _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+std_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+std_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+std_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+std_out_ttllb _out _self _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+std_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+std_out_ttll _out _self _dim _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+std_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+std_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+std_tNbb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+std_tNbb _self _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+std_tNb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+std_tNb _self _dim _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+std_tN
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+std_tN _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+std_out_ttNbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+std_out_ttNbb _out _self _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+std_out_ttNb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+std_out_ttNb _out _self _dim _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+std_out_ttN
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+std_out_ttN _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+std_tNlb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+std_tNlb _self _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+std_tNl
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> IO (Ptr Tensor)
+std_tNl _self _dim _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+std_out_ttNlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+std_out_ttNlb _out _self _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+std_out_ttNl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> IO (Ptr Tensor)
+std_out_ttNl _out _self _dim _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::std_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+prod_ts
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+prod_ts _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod(
+    *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+prod_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+prod_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod(
+    *$(at::Tensor* _self)));
+  }|]
+
+prod_tlbs
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+prod_tlbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+prod_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+prod_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+prod_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+prod_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+prod_out_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+prod_out_ttlbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+prod_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+prod_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+prod_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+prod_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+prod_tnbs
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+prod_tnbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+prod_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+prod_tnb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+prod_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+prod_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+prod_out_ttnbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+prod_out_ttnbs _out _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+prod_out_ttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+prod_out_ttnb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+prod_out_ttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+prod_out_ttn _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::prod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+t_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+t_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::t(
+    *$(at::Tensor* _self)));
+  }|]
+
+tan_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tan_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tan(
+    *$(at::Tensor* _self)));
+  }|]
+
+tan__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tan__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tan_(
+    *$(at::Tensor* _self)));
+  }|]
+
+tan_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tan_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tan_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+tanh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tanh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tanh(
+    *$(at::Tensor* _self)));
+  }|]
+
+tanh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tanh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tanh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+tanh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tanh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tanh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+tensordot_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensordot_ttll _self _other _dims_self _dims_other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tensordot(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::vector<int64_t>* _dims_self)
+  , *$(std::vector<int64_t>* _dims_other)));
+  }|]
+
+tensordot_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensordot_out_tttll _out _self _other _dims_self _dims_other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tensordot_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::vector<int64_t>* _dims_self)
+  , *$(std::vector<int64_t>* _dims_other)));
+  }|]
+
+threshold_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+threshold_tss _self _threshold _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::threshold(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _threshold)
+  , *$(at::Scalar* _value)));
+  }|]
+
+threshold__tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+threshold__tss _self _threshold _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::threshold_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _threshold)
+  , *$(at::Scalar* _value)));
+  }|]
+
+threshold_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+threshold_out_ttss _out _self _threshold _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::threshold_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _threshold)
+  , *$(at::Scalar* _value)));
+  }|]
+
+threshold_backward_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+threshold_backward_out_ttts _grad_input _grad_output _self _threshold =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::threshold_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _threshold)));
+  }|]
+
+threshold_backward_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+threshold_backward_tts _grad_output _self _threshold =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::threshold_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _threshold)));
+  }|]
+
+tile_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tile_tl _self _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tile(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+transpose_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+transpose_tll _self _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::transpose(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+transpose_tnn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+transpose_tnn _self _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::transpose(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim0)
+  , *$(at::Dimname* _dim1)));
+  }|]
+
+_mkldnn_transpose_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_mkldnn_transpose_tll _self _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mkldnn_transpose(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+_mkldnn_transpose__tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_mkldnn_transpose__tll _self _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_mkldnn_transpose_(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+one_hot_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+one_hot_tl _self _num_classes =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::one_hot(
+    *$(at::Tensor* _self)
+  , $(int64_t _num_classes)));
+  }|]
+
+one_hot_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+one_hot_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::one_hot(
+    *$(at::Tensor* _self)));
+  }|]
+
+flip_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+flip_tl _self _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flip(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+fliplr_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fliplr_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fliplr(
+    *$(at::Tensor* _self)));
+  }|]
+
+flipud_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+flipud_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::flipud(
+    *$(at::Tensor* _self)));
+  }|]
+
+roll_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+roll_tll _self _shifts _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::roll(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _shifts)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+roll_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+roll_tl _self _shifts =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::roll(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _shifts)));
+  }|]
+
+rot90_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+rot90_tll _self _k _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rot90(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+rot90_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+rot90_tl _self _k =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rot90(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)));
+  }|]
+
+rot90_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+rot90_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rot90(
+    *$(at::Tensor* _self)));
+  }|]
+
+trapezoid_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+trapezoid_ttl _y _x _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapezoid(
+    *$(at::Tensor* _y)
+  , *$(at::Tensor* _x)
+  , $(int64_t _dim)));
+  }|]
+
+trapezoid_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+trapezoid_tt _y _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapezoid(
+    *$(at::Tensor* _y)
+  , *$(at::Tensor* _x)));
+  }|]
+
+trapezoid_tsl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr Tensor)
+trapezoid_tsl _y _dx _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapezoid(
+    *$(at::Tensor* _y)
+  , *$(at::Scalar* _dx)
+  , $(int64_t _dim)));
+  }|]
+
+trapezoid_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+trapezoid_ts _y _dx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapezoid(
+    *$(at::Tensor* _y)
+  , *$(at::Scalar* _dx)));
+  }|]
+
+trapezoid_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+trapezoid_t _y =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapezoid(
+    *$(at::Tensor* _y)));
+  }|]
+
+trapz_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+trapz_ttl _y _x _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapz(
+    *$(at::Tensor* _y)
+  , *$(at::Tensor* _x)
+  , $(int64_t _dim)));
+  }|]
+
+trapz_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+trapz_tt _y _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapz(
+    *$(at::Tensor* _y)
+  , *$(at::Tensor* _x)));
+  }|]
+
+trapz_tdl
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+trapz_tdl _y _dx _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapz(
+    *$(at::Tensor* _y)
+  , $(double _dx)
+  , $(int64_t _dim)));
+  }|]
+
+trapz_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+trapz_td _y _dx =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapz(
+    *$(at::Tensor* _y)
+  , $(double _dx)));
+  }|]
+
+trapz_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+trapz_t _y =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trapz(
+    *$(at::Tensor* _y)));
+  }|]
+
+_transform_bias_rescale_qkv_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_transform_bias_rescale_qkv_ttl _qkv _qkv_bias _num_heads =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_transform_bias_rescale_qkv(
+    *$(at::Tensor* _qkv)
+  , *$(at::Tensor* _qkv_bias)
+  , $(int64_t _num_heads)));
+  }|]
+
+_nested_tensor_from_mask_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_nested_tensor_from_mask_ttb _t _mask _mask_check =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_mask(
+    *$(at::Tensor* _t)
+  , *$(at::Tensor* _mask)
+  , $(bool _mask_check)));
+  }|]
+
+_nested_tensor_from_mask_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_tensor_from_mask_tt _t _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_mask(
+    *$(at::Tensor* _t)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_nested_tensor_from_mask_left_aligned_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+_nested_tensor_from_mask_left_aligned_tt _t _mask =
+  [C.throwBlock| bool { return (at::_nested_tensor_from_mask_left_aligned(
+    *$(at::Tensor* _t)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_nested_from_padded_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_nested_from_padded_ttb _padded _cpu_nested_shape_example _fuse_transform_0213 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded(
+    *$(at::Tensor* _padded)
+  , *$(at::Tensor* _cpu_nested_shape_example)
+  , $(bool _fuse_transform_0213)));
+  }|]
+
+_nested_from_padded_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_from_padded_tt _padded _cpu_nested_shape_example =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded(
+    *$(at::Tensor* _padded)
+  , *$(at::Tensor* _cpu_nested_shape_example)));
+  }|]
+
+_nested_from_padded_and_nested_example_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_nested_from_padded_and_nested_example_tt _padded _nt_example =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded_and_nested_example(
+    *$(at::Tensor* _padded)
+  , *$(at::Tensor* _nt_example)));
+  }|]
+
+_trilinear_tttlllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+_trilinear_tttlllll _i1 _i2 _i3 _expand1 _expand2 _expand3 _sumdim _unroll_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_trilinear(
+    *$(at::Tensor* _i1)
+  , *$(at::Tensor* _i2)
+  , *$(at::Tensor* _i3)
+  , *$(std::vector<int64_t>* _expand1)
+  , *$(std::vector<int64_t>* _expand2)
+  , *$(std::vector<int64_t>* _expand3)
+  , *$(std::vector<int64_t>* _sumdim)
+  , $(int64_t _unroll_dim)));
+  }|]
+
+_trilinear_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_trilinear_tttllll _i1 _i2 _i3 _expand1 _expand2 _expand3 _sumdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_trilinear(
+    *$(at::Tensor* _i1)
+  , *$(at::Tensor* _i2)
+  , *$(at::Tensor* _i3)
+  , *$(std::vector<int64_t>* _expand1)
+  , *$(std::vector<int64_t>* _expand2)
+  , *$(std::vector<int64_t>* _expand3)
+  , *$(std::vector<int64_t>* _sumdim)));
+  }|]
+
+triplet_margin_loss_tttdddbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+triplet_margin_loss_tttdddbl _anchor _positive _negative _margin _p _eps _swap _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triplet_margin_loss(
+    *$(at::Tensor* _anchor)
+  , *$(at::Tensor* _positive)
+  , *$(at::Tensor* _negative)
+  , $(double _margin)
+  , $(double _p)
+  , $(double _eps)
+  , $(bool _swap)
+  , $(int64_t _reduction)));
+  }|]
+
+triplet_margin_loss_tttdddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+triplet_margin_loss_tttdddb _anchor _positive _negative _margin _p _eps _swap =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triplet_margin_loss(
+    *$(at::Tensor* _anchor)
+  , *$(at::Tensor* _positive)
+  , *$(at::Tensor* _negative)
+  , $(double _margin)
+  , $(double _p)
+  , $(double _eps)
+  , $(bool _swap)));
+  }|]
+
+triplet_margin_loss_tttddd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+triplet_margin_loss_tttddd _anchor _positive _negative _margin _p _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triplet_margin_loss(
+    *$(at::Tensor* _anchor)
+  , *$(at::Tensor* _positive)
+  , *$(at::Tensor* _negative)
+  , $(double _margin)
+  , $(double _p)
+  , $(double _eps)));
+  }|]
+
+triplet_margin_loss_tttdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+triplet_margin_loss_tttdd _anchor _positive _negative _margin _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triplet_margin_loss(
+    *$(at::Tensor* _anchor)
+  , *$(at::Tensor* _positive)
+  , *$(at::Tensor* _negative)
+  , $(double _margin)
+  , $(double _p)));
+  }|]
+
+triplet_margin_loss_tttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+triplet_margin_loss_tttd _anchor _positive _negative _margin =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triplet_margin_loss(
+    *$(at::Tensor* _anchor)
+  , *$(at::Tensor* _positive)
+  , *$(at::Tensor* _negative)
+  , $(double _margin)));
+  }|]
+
+triplet_margin_loss_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+triplet_margin_loss_ttt _anchor _positive _negative =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triplet_margin_loss(
+    *$(at::Tensor* _anchor)
+  , *$(at::Tensor* _positive)
+  , *$(at::Tensor* _negative)));
+  }|]
+
+trunc_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+trunc_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trunc(
+    *$(at::Tensor* _self)));
+  }|]
+
+trunc__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+trunc__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trunc_(
+    *$(at::Tensor* _self)));
+  }|]
+
+trunc_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+trunc_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trunc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+fix_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fix_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fix(
+    *$(at::Tensor* _self)));
+  }|]
+
+fix__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+fix__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fix_(
+    *$(at::Tensor* _self)));
+  }|]
+
+fix_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fix_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fix_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_has_compatible_shallow_copy_type_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+_has_compatible_shallow_copy_type_tt _self _from =
+  [C.throwBlock| bool { return (at::_has_compatible_shallow_copy_type(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _from)));
+  }|]
+
+_unique_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_unique_tbb _self _sorted _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_unique(
+    *$(at::Tensor* _self)
+  , $(bool _sorted)
+  , $(bool _return_inverse)));
+  }|]
+
+_unique_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_unique_tb _self _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_unique(
+    *$(at::Tensor* _self)
+  , $(bool _sorted)));
+  }|]
+
+_unique_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_unique_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_unique(
+    *$(at::Tensor* _self)));
+  }|]
+
+unique_dim_tlbbb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_tlbbb _self _dim _sorted _return_inverse _return_counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _sorted)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)));
+  }|]
+
+unique_dim_tlbb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_tlbb _self _dim _sorted _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _sorted)
+  , $(bool _return_inverse)));
+  }|]
+
+unique_dim_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_tlb _self _dim _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _sorted)));
+  }|]
+
+unique_dim_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+unique_consecutive_tbbl
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_tbbl _self _return_inverse _return_counts _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive(
+    *$(at::Tensor* _self)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)
+  , $(int64_t _dim)));
+  }|]
+
+unique_consecutive_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_tbb _self _return_inverse _return_counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive(
+    *$(at::Tensor* _self)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)));
+  }|]
+
+unique_consecutive_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_tb _self _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive(
+    *$(at::Tensor* _self)
+  , $(bool _return_inverse)));
+  }|]
+
+unique_consecutive_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_consecutive_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive(
+    *$(at::Tensor* _self)));
+  }|]
+
+unique_dim_consecutive_tlbb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_tlbb _self _dim _return_inverse _return_counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_consecutive(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)));
+  }|]
+
+unique_dim_consecutive_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_tlb _self _dim _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_consecutive(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _return_inverse)));
+  }|]
+
+unique_dim_consecutive_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+unique_dim_consecutive_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_consecutive(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+_unique2_tbbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_tbbb _self _sorted _return_inverse _return_counts =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2(
+    *$(at::Tensor* _self)
+  , $(bool _sorted)
+  , $(bool _return_inverse)
+  , $(bool _return_counts)));
+  }|]
+
+_unique2_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_tbb _self _sorted _return_inverse =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2(
+    *$(at::Tensor* _self)
+  , $(bool _sorted)
+  , $(bool _return_inverse)));
+  }|]
+
+_unique2_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_tb _self _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2(
+    *$(at::Tensor* _self)
+  , $(bool _sorted)));
+  }|]
+
+_unique2_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_unique2_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2(
+    *$(at::Tensor* _self)));
+  }|]
+
+_unsafe_view_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_unsafe_view_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_unsafe_view(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+unsqueeze_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+unsqueeze_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unsqueeze(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+vander_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+vander_tlb _x _N _increasing =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::vander(
+    *$(at::Tensor* _x)
+  , $(int64_t _N)
+  , $(bool _increasing)));
+  }|]
+
+vander_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+vander_tl _x _N =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::vander(
+    *$(at::Tensor* _x)
+  , $(int64_t _N)));
+  }|]
+
+vander_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+vander_t _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::vander(
+    *$(at::Tensor* _x)));
+  }|]
+
+var_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+var_tb _self _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , $(bool _unbiased)));
+  }|]
+
+var_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+var_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)));
+  }|]
+
+var_tlbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+var_tlbb _self _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+var_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+var_tlb _self _dim _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+var_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+var_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+var_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+var_tllb _self _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+var_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+var_tll _self _dim _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+var_out_ttlbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+var_out_ttlbb _out _self _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+var_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+var_out_ttlb _out _self _dim _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+var_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+var_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+var_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+var_out_ttllb _out _self _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+var_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+var_out_ttll _out _self _dim _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+var_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+var_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+var_tNbb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+var_tNbb _self _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+var_tNb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+var_tNb _self _dim _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+var_tN
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+var_tN _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+var_out_ttNbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+var_out_ttNbb _out _self _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+var_out_ttNb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+var_out_ttNb _out _self _dim _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+var_out_ttN
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+var_out_ttN _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+var_tNlb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+var_tNlb _self _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+var_tNl
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> IO (Ptr Tensor)
+var_tNl _self _dim _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+var_out_ttNlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+var_out_ttNlb _out _self _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+var_out_ttNl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> IO (Ptr Tensor)
+var_out_ttNl _out _self _dim _correction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::var_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+var_mean_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tb _self _unbiased =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , $(bool _unbiased)));
+  }|]
+
+var_mean_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)));
+  }|]
+
+var_mean_tlbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tlbb _self _dim _unbiased _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+var_mean_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tlb _self _dim _unbiased =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+var_mean_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+var_mean_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tllb _self _dim _correction _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+var_mean_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tll _self _dim _correction =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+var_mean_tNbb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tNbb _self _dim _unbiased _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+var_mean_tNb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tNb _self _dim _unbiased =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)));
+  }|]
+
+var_mean_tN
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tN _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+var_mean_tNlb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tNlb _self _dim _correction _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+var_mean_tNl
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+var_mean_tNl _self _dim _correction =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)));
+  }|]
+
+where_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+where_ttt _condition _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::where(
+    *$(at::Tensor* _condition)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+where_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+where_out_tttt _out _condition _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::where_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _condition)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+where_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+where_tst _condition _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::where(
+    *$(at::Tensor* _condition)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+where_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+where_tts _condition _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::where(
+    *$(at::Tensor* _condition)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+where_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+where_tss _condition _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::where(
+    *$(at::Tensor* _condition)
+  , *$(at::Scalar* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+where_t
+  :: Ptr Tensor
+  -> IO (Ptr TensorList)
+where_t _condition =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::where(
+    *$(at::Tensor* _condition)));
+  }|]
+
+norm_except_dim_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+norm_except_dim_tll _v _pow _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_except_dim(
+    *$(at::Tensor* _v)
+  , $(int64_t _pow)
+  , $(int64_t _dim)));
+  }|]
+
+norm_except_dim_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+norm_except_dim_tl _v _pow =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_except_dim(
+    *$(at::Tensor* _v)
+  , $(int64_t _pow)));
+  }|]
+
+norm_except_dim_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+norm_except_dim_t _v =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_except_dim(
+    *$(at::Tensor* _v)));
+  }|]
+
+_weight_norm_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_weight_norm_ttl _v _g _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_weight_norm(
+    *$(at::Tensor* _v)
+  , *$(at::Tensor* _g)
+  , $(int64_t _dim)));
+  }|]
+
+_weight_norm_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_weight_norm_tt _v _g =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_weight_norm(
+    *$(at::Tensor* _v)
+  , *$(at::Tensor* _g)));
+  }|]
+
+_weight_norm_interface_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_ttl _v _g _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_interface(
+    *$(at::Tensor* _v)
+  , *$(at::Tensor* _g)
+  , $(int64_t _dim)));
+  }|]
+
+_weight_norm_interface_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_tt _v _g =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_interface(
+    *$(at::Tensor* _v)
+  , *$(at::Tensor* _g)));
+  }|]
+
+_weight_norm_interface_backward_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_weight_norm_interface_backward_ttttl _grad_w _saved_v _saved_g _saved_norms _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_interface_backward(
+    *$(at::Tensor* _grad_w)
+  , *$(at::Tensor* _saved_v)
+  , *$(at::Tensor* _saved_g)
+  , *$(at::Tensor* _saved_norms)
+  , $(int64_t _dim)));
+  }|]
+
+_weight_norm_differentiable_backward_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_weight_norm_differentiable_backward_ttttl _grad_w _saved_v _saved_g _saved_norms _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_differentiable_backward(
+    *$(at::Tensor* _grad_w)
+  , *$(at::Tensor* _saved_v)
+  , *$(at::Tensor* _saved_g)
+  , *$(at::Tensor* _saved_norms)
+  , $(int64_t _dim)));
+  }|]
+
+zeros_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+zeros_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+zeros_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+zeros_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+_efficientzerotensor_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_efficientzerotensor_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_efficientzerotensor(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_efficientzerotensor_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+_efficientzerotensor_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_efficientzerotensor(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+zeros_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+zeros_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+zeros_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+zeros_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+zeros_out_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+zeros_out_tl _out _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_out(
+    *$(at::Tensor* _out)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+zeros_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+zeros_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+zeros_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+zeros_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> IO (Ptr Tensor)
+_standard_gamma_grad_tt _self _output =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_standard_gamma_grad(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _output)));
+  }|]
+
+_standard_gamma_tG
+  :: Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+_standard_gamma_tG _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_standard_gamma(
+    *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+_standard_gamma_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_standard_gamma_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_standard_gamma(
+    *$(at::Tensor* _self)));
+  }|]
+
+_dirichlet_grad_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_dirichlet_grad_ttt _x _alpha _total =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_dirichlet_grad(
+    *$(at::Tensor* _x)
+  , *$(at::Tensor* _alpha)
+  , *$(at::Tensor* _total)));
+  }|]
+
+_sample_dirichlet_tG
+  :: Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+_sample_dirichlet_tG _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sample_dirichlet(
+    *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+_sample_dirichlet_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_sample_dirichlet_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sample_dirichlet(
+    *$(at::Tensor* _self)));
+  }|]
+
+poisson_tG
+  :: Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+poisson_tG _self _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::poisson(
+    *$(at::Tensor* _self)
+  , *$(at::Generator* _generator)));
+  }|]
+
+poisson_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+poisson_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::poisson(
+    *$(at::Tensor* _self)));
+  }|]
+
+binomial_ttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+binomial_ttG _count _prob _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binomial(
+    *$(at::Tensor* _count)
+  , *$(at::Tensor* _prob)
+  , *$(at::Generator* _generator)));
+  }|]
+
+binomial_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+binomial_tt _count _prob =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binomial(
+    *$(at::Tensor* _count)
+  , *$(at::Tensor* _prob)));
+  }|]
+
+native_norm_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+native_norm_ts _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)));
+  }|]
+
+native_norm_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+native_norm_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_norm(
+    *$(at::Tensor* _self)));
+  }|]
+
+native_norm_tslbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+native_norm_tslbs _self _p _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::native_norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_sum_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_sum_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sum(
+    *$(at::Tensor* _self)));
+  }|]
+
+_sparse_sum_ts
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_sum_ts _self _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sum(
+    *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_sum_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_sum_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+_sparse_sum_tls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_sum_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_sum_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_sum_backward_ttl _grad _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_sum_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+_sparse_csr_sum_tlbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_csr_sum_tlbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_csr_sum_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_sparse_csr_sum_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+_sparse_csr_sum_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_csr_sum_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_sum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+_sparse_csr_prod_tlbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_csr_prod_tlbs _self _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_prod(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_csr_prod_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_sparse_csr_prod_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_prod(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+_sparse_csr_prod_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_csr_prod_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_prod(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+_sparse_softmax_tls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_softmax_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_softmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_sparse_softmax_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+_sparse_softmax_tns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_softmax_tns _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_softmax_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+_sparse_softmax_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+_sparse_softmax_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_sparse_softmax_tlb _self _dim _half_to_float =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _half_to_float)));
+  }|]
+
+_sparse_softmax_backward_data_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_softmax_backward_data_ttlt _grad_output _output _dim _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_softmax_backward_data(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_sparse_log_softmax_tls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_log_softmax_tls _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_log_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_log_softmax_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_sparse_log_softmax_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_log_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+_sparse_log_softmax_tns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+_sparse_log_softmax_tns _self _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_log_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+_sparse_log_softmax_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+_sparse_log_softmax_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_log_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+_sparse_log_softmax_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_sparse_log_softmax_tlb _self _dim _half_to_float =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_log_softmax(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _half_to_float)));
+  }|]
+
+_sparse_log_softmax_backward_data_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_log_softmax_backward_data_ttlt _grad_output _output _dim _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_log_softmax_backward_data(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_spdiags_ttlL
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Layout
+  -> IO (Ptr Tensor)
+_spdiags_ttlL _diagonals _offsets _shape _layout =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_spdiags(
+    *$(at::Tensor* _diagonals)
+  , *$(at::Tensor* _offsets)
+  , *$(std::vector<int64_t>* _shape)
+  , $(at::Layout _layout)));
+  }|]
+
+_spdiags_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_spdiags_ttl _diagonals _offsets _shape =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_spdiags(
+    *$(at::Tensor* _diagonals)
+  , *$(at::Tensor* _offsets)
+  , *$(std::vector<int64_t>* _shape)));
+  }|]
+
+norm_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> ScalarType
+  -> IO (Ptr Tensor)
+norm_tss _self _p _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+norm_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+norm_ts _self _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)));
+  }|]
+
+norm_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+norm_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)));
+  }|]
+
+norm_tslbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+norm_tslbs _self _p _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+norm_tslb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+norm_tslb _self _p _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+norm_tsl
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+norm_tsl _self _p _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+norm_out_ttslbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+norm_out_ttslbs _out _self _p _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+norm_out_ttslb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+norm_out_ttslb _out _self _p _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+norm_out_ttsl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+norm_out_ttsl _out _self _p _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+norm_tsNbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+norm_tsNbs _self _p _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+norm_tsNb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+norm_tsNb _self _p _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+norm_tsN
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+norm_tsN _self _p _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+norm_out_ttsNbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+norm_out_ttsNbs _out _self _p _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+norm_out_ttsNb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+norm_out_ttsNb _out _self _p _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+norm_out_ttsN
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+norm_out_ttsN _out _self _p _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , *$(std::vector<at::Dimname>* _dim)));
+  }|]
+
+frexp_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+frexp_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::frexp(
+    *$(at::Tensor* _self)));
+  }|]
+
+frexp_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+frexp_out_ttt _mantissa _exponent _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::frexp_out(
+    *$(at::Tensor* _mantissa)
+  , *$(at::Tensor* _exponent)
+  , *$(at::Tensor* _self)));
+  }|]
+
+frobenius_norm_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+frobenius_norm_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::frobenius_norm(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+frobenius_norm_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+frobenius_norm_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::frobenius_norm(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+frobenius_norm_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+frobenius_norm_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::frobenius_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+frobenius_norm_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+frobenius_norm_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::frobenius_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+nuclear_norm_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+nuclear_norm_tb _self _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nuclear_norm(
+    *$(at::Tensor* _self)
+  , $(bool _keepdim)));
+  }|]
+
+nuclear_norm_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+nuclear_norm_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nuclear_norm(
+    *$(at::Tensor* _self)));
+  }|]
+
+nuclear_norm_out_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+nuclear_norm_out_ttb _out _self _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nuclear_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _keepdim)));
+  }|]
+
+nuclear_norm_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nuclear_norm_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nuclear_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+nuclear_norm_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+nuclear_norm_tlb _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nuclear_norm(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nuclear_norm_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+nuclear_norm_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nuclear_norm(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+nuclear_norm_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+nuclear_norm_out_ttlb _out _self _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nuclear_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nuclear_norm_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+nuclear_norm_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nuclear_norm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _dim)));
+  }|]
+
+clone_tM
+  :: Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+clone_tM _self _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clone(
+    *$(at::Tensor* _self)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+clone_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+clone_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clone(
+    *$(at::Tensor* _self)));
+  }|]
+
+positive_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+positive_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::positive(
+    *$(at::Tensor* _self)));
+  }|]
+
+resize_as__ttM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+resize_as__ttM _self _the_template _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+resize_as__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+resize_as__tt _self _the_template =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)));
+  }|]
+
+resize_as_sparse__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+resize_as_sparse__tt _self _the_template =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as_sparse_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _the_template)));
+  }|]
+
+zero__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+zero__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zero_(
+    *$(at::Tensor* _self)));
+  }|]
+
+sub_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sub_out_ttts _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sub_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+sub_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sub_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sub_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+sub_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sub_tts _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sub(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+sub_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sub_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sub(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+sub_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sub_tss _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sub(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+sub_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sub_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sub(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+subtract_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+subtract_out_ttts _out _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::subtract_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+subtract_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+subtract_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::subtract_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+subtract_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+subtract_tts _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::subtract(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+subtract_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+subtract_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::subtract(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native6.hs b/src/Torch/Internal/Unmanaged/Native/Native6.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native6.hs
@@ -0,0 +1,4168 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native6 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+subtract_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+subtract_tss _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::subtract(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+subtract_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+subtract_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::subtract(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+rsub_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rsub_tts _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsub(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+rsub_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rsub_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsub(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+heaviside_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+heaviside_out_ttt _out _self _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::heaviside_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _values)));
+  }|]
+
+heaviside_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+heaviside_tt _self _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::heaviside(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _values)));
+  }|]
+
+rsub_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rsub_tss _self _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsub(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+rsub_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rsub_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rsub(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+_sparse_addmm_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_sparse_addmm_tttss _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_sparse_addmm_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_sparse_addmm_ttts _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+_sparse_addmm_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_sparse_addmm_ttt _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+sparse_sampled_addmm_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sparse_sampled_addmm_out_ttttss _out _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_sampled_addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+sparse_sampled_addmm_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sparse_sampled_addmm_out_tttts _out _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_sampled_addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+sparse_sampled_addmm_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sparse_sampled_addmm_out_tttt _out _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_sampled_addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+sparse_sampled_addmm_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sparse_sampled_addmm_tttss _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_sampled_addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+sparse_sampled_addmm_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+sparse_sampled_addmm_ttts _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_sampled_addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+sparse_sampled_addmm_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sparse_sampled_addmm_ttt _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_sampled_addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+_sparse_mm_reduce_impl_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_sparse_mm_reduce_impl_tts _self _other _reduce =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_sparse_mm_reduce_impl(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(std::string* _reduce)));
+  }|]
+
+_sparse_mm_reduce_impl_backward_tttsta
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> Ptr (StdArray '(CBool,2))
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_sparse_mm_reduce_impl_backward_tttsta _self _grad_out _weight _reduce _arg_out _output_mask =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_sparse_mm_reduce_impl_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _grad_out)
+  , *$(at::Tensor* _weight)
+  , *$(std::string* _reduce)
+  , *$(at::Tensor* _arg_out)
+  , *$(std::array<bool,2>* _output_mask)));
+  }|]
+
+addmm_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmm_out_ttttss _out _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addmm_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmm_out_tttts _out _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addmm_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addmm_out_tttt _out _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+addmm_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmm_tttss _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addmm_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addmm_ttts _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addmm_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addmm_ttt _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+_addmm_activation_out_ttttssb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+_addmm_activation_out_ttttssb _out _self _mat1 _mat2 _beta _alpha _use_gelu =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_addmm_activation_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)
+  , $(bool _use_gelu)));
+  }|]
+
+_addmm_activation_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_addmm_activation_out_ttttss _out _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_addmm_activation_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_addmm_activation_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_addmm_activation_out_tttts _out _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_addmm_activation_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+_addmm_activation_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_addmm_activation_out_tttt _out _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_addmm_activation_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+_addmm_activation_tttssb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+_addmm_activation_tttssb _self _mat1 _mat2 _beta _alpha _use_gelu =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_addmm_activation(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)
+  , $(bool _use_gelu)));
+  }|]
+
+_addmm_activation_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_addmm_activation_tttss _self _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_addmm_activation(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_addmm_activation_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+_addmm_activation_ttts _self _mat1 _mat2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_addmm_activation(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+_addmm_activation_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_addmm_activation_ttt _self _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_addmm_activation(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+sparse_compressed_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_compressed_tensor_tttlo _compressed_indices _plain_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_compressed_tensor(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_csr_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_csr_tensor_tttlo _crow_indices _col_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_csr_tensor(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_csc_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_csc_tensor_tttlo _ccol_indices _row_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_csc_tensor(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_bsr_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_bsr_tensor_tttlo _crow_indices _col_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_bsr_tensor(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_bsc_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_bsc_tensor_tttlo _ccol_indices _row_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_bsc_tensor(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_compressed_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_compressed_tensor_ttto _compressed_indices _plain_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_compressed_tensor(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_csr_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_csr_tensor_ttto _crow_indices _col_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_csr_tensor(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_csc_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_csc_tensor_ttto _ccol_indices _row_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_csc_tensor(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_bsr_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_bsr_tensor_ttto _crow_indices _col_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_bsr_tensor(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_bsc_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_bsc_tensor_ttto _ccol_indices _row_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_bsc_tensor(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_compressed_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_compressed_tensor_unsafe_tttlo _compressed_indices _plain_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_compressed_tensor_unsafe(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_compressed_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_compressed_tensor_unsafe_tttl _compressed_indices _plain_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_compressed_tensor_unsafe(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_csr_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_csr_tensor_unsafe_tttlo _crow_indices _col_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_tensor_unsafe(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_csr_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_csr_tensor_unsafe_tttl _crow_indices _col_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csr_tensor_unsafe(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_csc_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_csc_tensor_unsafe_tttlo _ccol_indices _row_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csc_tensor_unsafe(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_csc_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_csc_tensor_unsafe_tttl _ccol_indices _row_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_csc_tensor_unsafe(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_bsr_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_bsr_tensor_unsafe_tttlo _crow_indices _col_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_bsr_tensor_unsafe(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_bsr_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_bsr_tensor_unsafe_tttl _crow_indices _col_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_bsr_tensor_unsafe(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_bsc_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_bsc_tensor_unsafe_tttlo _ccol_indices _row_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_bsc_tensor_unsafe(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_bsc_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_bsc_tensor_unsafe_tttl _ccol_indices _row_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_bsc_tensor_unsafe(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+sparse_coo_tensor_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_coo_tensor(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_coo_tensor_tto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_tto _indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_coo_tensor(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_coo_tensor_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_tt _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_coo_tensor(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+sparse_coo_tensor_ttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_ttlo _indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_coo_tensor(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_coo_tensor_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_ttl _indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_coo_tensor(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_coo_tensor_unsafe_ttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_unsafe_ttlo _indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_coo_tensor_unsafe(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_coo_tensor_unsafe_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_unsafe_ttl _indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_coo_tensor_unsafe(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_validate_sparse_coo_tensor_args_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+_validate_sparse_coo_tensor_args_ttl _indices _values _size =
+  [C.throwBlock| void {  (at::_validate_sparse_coo_tensor_args(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_validate_sparse_compressed_tensor_args_tttlL
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Layout
+  -> IO (())
+_validate_sparse_compressed_tensor_args_tttlL _compressed_indices _plain_indices _values _size _layout =
+  [C.throwBlock| void {  (at::_validate_sparse_compressed_tensor_args(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , $(at::Layout _layout)));
+  }|]
+
+_validate_sparse_csr_tensor_args_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+_validate_sparse_csr_tensor_args_tttl _crow_indices _col_indices _values _size =
+  [C.throwBlock| void {  (at::_validate_sparse_csr_tensor_args(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_validate_sparse_csc_tensor_args_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+_validate_sparse_csc_tensor_args_tttl _ccol_indices _row_indices _values _size =
+  [C.throwBlock| void {  (at::_validate_sparse_csc_tensor_args(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_validate_sparse_bsr_tensor_args_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+_validate_sparse_bsr_tensor_args_tttl _crow_indices _col_indices _values _size =
+  [C.throwBlock| void {  (at::_validate_sparse_bsr_tensor_args(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_validate_sparse_bsc_tensor_args_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (())
+_validate_sparse_bsc_tensor_args_tttl _ccol_indices _row_indices _values _size =
+  [C.throwBlock| void {  (at::_validate_sparse_bsc_tensor_args(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_coo_tensor_with_dims_lllo
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_with_dims_lllo _sparse_dim _dense_dim _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_coo_tensor_with_dims(
+    $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_coo_tensor_with_dims_and_tensors_llltto
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_with_dims_and_tensors_llltto _sparse_dim _dense_dim _size _indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_coo_tensor_with_dims_and_tensors(
+    $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_to_cpu_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_to_cpu_l _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_to_cpu(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+to_dense_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+to_dense_backward_tt _grad _input =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::to_dense_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _input)));
+  }|]
+
+_coalesce_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_coalesce_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_coalesce(
+    *$(at::Tensor* _self)));
+  }|]
+
+hspmm_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hspmm_out_ttt _out _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hspmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+hspmm_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hspmm_tt _mat1 _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hspmm(
+    *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)));
+  }|]
+
+copy_sparse_to_sparse__ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+copy_sparse_to_sparse__ttb _self _src _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_sparse_to_sparse_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)
+  , $(bool _non_blocking)));
+  }|]
+
+copy_sparse_to_sparse__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+copy_sparse_to_sparse__tt _self _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_sparse_to_sparse_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _src)));
+  }|]
+
+unbind_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+unbind_tl _self _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unbind(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+unbind_t
+  :: Ptr Tensor
+  -> IO (Ptr TensorList)
+unbind_t _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unbind(
+    *$(at::Tensor* _self)));
+  }|]
+
+unbind_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr TensorList)
+unbind_tn _self _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unbind(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_tlllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_tlllll _self _padding _stride _dilation _groups _input_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)
+  , *$(std::vector<int64_t>* _input_size)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_tllll _self _padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_tlll _self _padding _stride _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_tll _self _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_tl _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_reorder_conv2d_weight_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv2d_weight_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv2d_weight(
+    *$(at::Tensor* _self)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_tllll _self _padding _stride _dilation _groups =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(int64_t _groups)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_tlll _self _padding _stride _dilation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_tll _self _padding _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_tl _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+mkldnn_reorder_conv3d_weight_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_reorder_conv3d_weight_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight(
+    *$(at::Tensor* _self)));
+  }|]
+
+to_mkldnn_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+to_mkldnn_backward_tt _grad _input =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::to_mkldnn_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _input)));
+  }|]
+
+quantize_per_tensor_dynamic_tsb
+  :: Ptr Tensor
+  -> ScalarType
+  -> CBool
+  -> IO (Ptr Tensor)
+quantize_per_tensor_dynamic_tsb _self _dtype _reduce_range =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor_dynamic(
+    *$(at::Tensor* _self)
+  , $(at::ScalarType _dtype)
+  , $(bool _reduce_range)));
+  }|]
+
+quantize_per_tensor_tdls
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+quantize_per_tensor_tdls _self _scale _zero_point _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor(
+    *$(at::Tensor* _self)
+  , $(double _scale)
+  , $(int64_t _zero_point)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+quantize_per_tensor_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+quantize_per_tensor_ttts _self _scale _zero_point _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+quantize_per_tensor_ltts
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr TensorList)
+quantize_per_tensor_ltts _tensors _scales _zero_points _dtype =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::quantize_per_tensor(
+    *$(std::vector<at::Tensor>* _tensors)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+quantize_per_channel_tttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+quantize_per_channel_tttls _self _scales _zero_points _axis _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_channel(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+dequantize_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+dequantize_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dequantize(
+    *$(at::Tensor* _self)));
+  }|]
+
+dequantize_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+dequantize_l _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::dequantize(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+q_scale_t
+  :: Ptr Tensor
+  -> IO (CDouble)
+q_scale_t _self =
+  [C.throwBlock| double { return (at::q_scale(
+    *$(at::Tensor* _self)));
+  }|]
+
+q_zero_point_t
+  :: Ptr Tensor
+  -> IO (Int64)
+q_zero_point_t _self =
+  [C.throwBlock| int64_t { return (at::q_zero_point(
+    *$(at::Tensor* _self)));
+  }|]
+
+q_per_channel_scales_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+q_per_channel_scales_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::q_per_channel_scales(
+    *$(at::Tensor* _self)));
+  }|]
+
+q_per_channel_zero_points_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+q_per_channel_zero_points_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::q_per_channel_zero_points(
+    *$(at::Tensor* _self)));
+  }|]
+
+q_per_channel_axis_t
+  :: Ptr Tensor
+  -> IO (Int64)
+q_per_channel_axis_t _self =
+  [C.throwBlock| int64_t { return (at::q_per_channel_axis(
+    *$(at::Tensor* _self)));
+  }|]
+
+int_repr_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+int_repr_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::int_repr(
+    *$(at::Tensor* _self)));
+  }|]
+
+_make_per_tensor_quantized_tensor_tdl
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_make_per_tensor_quantized_tensor_tdl _self _scale _zero_point =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_per_tensor_quantized_tensor(
+    *$(at::Tensor* _self)
+  , $(double _scale)
+  , $(int64_t _zero_point)));
+  }|]
+
+_make_per_channel_quantized_tensor_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_make_per_channel_quantized_tensor_tttl _self _scale _zero_point _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_per_channel_quantized_tensor(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)));
+  }|]
+
+fake_quantize_per_tensor_affine_tdlll
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fake_quantize_per_tensor_affine_tdlll _self _scale _zero_point _quant_min _quant_max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fake_quantize_per_tensor_affine(
+    *$(at::Tensor* _self)
+  , $(double _scale)
+  , $(int64_t _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+fake_quantize_per_tensor_affine_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fake_quantize_per_tensor_affine_tttll _self _scale _zero_point _quant_min _quant_max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fake_quantize_per_tensor_affine(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+fake_quantize_per_tensor_affine_cachemask_tdlll
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+fake_quantize_per_tensor_affine_cachemask_tdlll _self _scale _zero_point _quant_min _quant_max =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fake_quantize_per_tensor_affine_cachemask(
+    *$(at::Tensor* _self)
+  , $(double _scale)
+  , $(int64_t _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_ttttll _self _scale _zero_point _fake_quant_enabled _quant_min _quant_max =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , *$(at::Tensor* _fake_quant_enabled)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+fake_quantize_per_tensor_affine_cachemask_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fake_quantize_per_tensor_affine_cachemask_backward_tt _grad _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fake_quantize_per_tensor_affine_cachemask_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_fake_quantize_learnable_per_tensor_affine_tttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+_fake_quantize_learnable_per_tensor_affine_tttlld _self _scale _zero_point _quant_min _quant_max _grad_factor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_tensor_affine(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(double _grad_factor)));
+  }|]
+
+_fake_quantize_learnable_per_tensor_affine_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_fake_quantize_learnable_per_tensor_affine_tttll _self _scale _zero_point _quant_min _quant_max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_tensor_affine(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+_fake_quantize_learnable_per_tensor_affine_backward_ttttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_fake_quantize_learnable_per_tensor_affine_backward_ttttlld _grad _self _scale _zero_point _quant_min _quant_max _grad_factor =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_fake_quantize_learnable_per_tensor_affine_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(double _grad_factor)));
+  }|]
+
+_fake_quantize_learnable_per_tensor_affine_backward_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_fake_quantize_learnable_per_tensor_affine_backward_ttttll _grad _self _scale _zero_point _quant_min _quant_max =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_fake_quantize_learnable_per_tensor_affine_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+fake_quantize_per_channel_affine_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fake_quantize_per_channel_affine_tttlll _self _scale _zero_point _axis _quant_min _quant_max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fake_quantize_per_channel_affine(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+fake_quantize_per_channel_affine_cachemask_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+fake_quantize_per_channel_affine_cachemask_tttlll _self _scale _zero_point _axis _quant_min _quant_max =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fake_quantize_per_channel_affine_cachemask(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+fake_quantize_per_channel_affine_cachemask_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fake_quantize_per_channel_affine_cachemask_backward_tt _grad _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fake_quantize_per_channel_affine_cachemask_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_fake_quantize_learnable_per_channel_affine_tttllld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+_fake_quantize_learnable_per_channel_affine_tttllld _self _scale _zero_point _axis _quant_min _quant_max _grad_factor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_channel_affine(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(double _grad_factor)));
+  }|]
+
+_fake_quantize_learnable_per_channel_affine_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_fake_quantize_learnable_per_channel_affine_tttlll _self _scale _zero_point _axis _quant_min _quant_max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_channel_affine(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+_fake_quantize_learnable_per_channel_affine_backward_ttttllld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_fake_quantize_learnable_per_channel_affine_backward_ttttllld _grad _self _scale _zero_point _axis _quant_min _quant_max _grad_factor =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_fake_quantize_learnable_per_channel_affine_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(double _grad_factor)));
+  }|]
+
+_fake_quantize_learnable_per_channel_affine_backward_ttttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_fake_quantize_learnable_per_channel_affine_backward_ttttlll _grad _self _scale _zero_point _axis _quant_min _quant_max =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_fake_quantize_learnable_per_channel_affine_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(int64_t _axis)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)));
+  }|]
+
+fused_moving_avg_obs_fake_quant_tttttttdlllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+fused_moving_avg_obs_fake_quant_tttttttdlllbb _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis _per_row_fake_quant _symmetric_quant =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fused_moving_avg_obs_fake_quant(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)
+  , $(bool _per_row_fake_quant)
+  , $(bool _symmetric_quant)));
+  }|]
+
+fused_moving_avg_obs_fake_quant_tttttttdlllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+fused_moving_avg_obs_fake_quant_tttttttdlllb _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis _per_row_fake_quant =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fused_moving_avg_obs_fake_quant(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)
+  , $(bool _per_row_fake_quant)));
+  }|]
+
+fused_moving_avg_obs_fake_quant_tttttttdlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+fused_moving_avg_obs_fake_quant_tttttttdlll _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fused_moving_avg_obs_fake_quant(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_tttttttdlllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_tttttttdlllbb _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis _per_row_fake_quant _symmetric_quant =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)
+  , $(bool _per_row_fake_quant)
+  , $(bool _symmetric_quant)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_tttttttdlllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_tttttttdlllb _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis _per_row_fake_quant =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)
+  , $(bool _per_row_fake_quant)));
+  }|]
+
+_fused_moving_avg_obs_fq_helper_tttttttdlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_fused_moving_avg_obs_fq_helper_tttttttdlll _self _observer_on _fake_quant_on _running_min _running_max _scale _zero_point _averaging_const _quant_min _quant_max _ch_axis =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _observer_on)
+  , *$(at::Tensor* _fake_quant_on)
+  , *$(at::Tensor* _running_min)
+  , *$(at::Tensor* _running_max)
+  , *$(at::Tensor* _scale)
+  , *$(at::Tensor* _zero_point)
+  , $(double _averaging_const)
+  , $(int64_t _quant_min)
+  , $(int64_t _quant_max)
+  , $(int64_t _ch_axis)));
+  }|]
+
+_choose_qparams_per_tensor_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(CDouble,Int64)))
+_choose_qparams_per_tensor_tb _self _reduce_range =
+  [C.throwBlock| std::tuple<double,int64_t>* { return new std::tuple<double,int64_t>(at::_choose_qparams_per_tensor(
+    *$(at::Tensor* _self)
+  , $(bool _reduce_range)));
+  }|]
+
+_choose_qparams_per_tensor_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(CDouble,Int64)))
+_choose_qparams_per_tensor_t _self =
+  [C.throwBlock| std::tuple<double,int64_t>* { return new std::tuple<double,int64_t>(at::_choose_qparams_per_tensor(
+    *$(at::Tensor* _self)));
+  }|]
+
+_saturate_weight_to_fp16_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_saturate_weight_to_fp16_t _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_saturate_weight_to_fp16(
+    *$(at::Tensor* _weight)));
+  }|]
+
+choose_qparams_optimized_tlldl
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+choose_qparams_optimized_tlldl _input _numel _n_bins _ratio _bit_width =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::choose_qparams_optimized(
+    *$(at::Tensor* _input)
+  , $(int64_t _numel)
+  , $(int64_t _n_bins)
+  , $(double _ratio)
+  , $(int64_t _bit_width)));
+  }|]
+
+_to_copy_tobM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> CBool
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_to_copy_tobM _self _options _non_blocking _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_copy(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(bool _non_blocking)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_to_copy_tob
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> CBool
+  -> IO (Ptr Tensor)
+_to_copy_tob _self _options _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_copy(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(bool _non_blocking)));
+  }|]
+
+_to_copy_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_to_copy_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_copy(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_to_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_to_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+meshgrid_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+meshgrid_l _tensors =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::meshgrid(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+meshgrid_ls
+  :: Ptr TensorList
+  -> Ptr StdString
+  -> IO (Ptr TensorList)
+meshgrid_ls _tensors _indexing =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::meshgrid(
+    *$(std::vector<at::Tensor>* _tensors)
+  , *$(std::string* _indexing)));
+  }|]
+
+cartesian_prod_l
+  :: Ptr TensorList
+  -> IO (Ptr Tensor)
+cartesian_prod_l _tensors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cartesian_prod(
+    *$(std::vector<at::Tensor>* _tensors)));
+  }|]
+
+combinations_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+combinations_tlb _self _r _with_replacement =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::combinations(
+    *$(at::Tensor* _self)
+  , $(int64_t _r)
+  , $(bool _with_replacement)));
+  }|]
+
+combinations_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+combinations_tl _self _r =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::combinations(
+    *$(at::Tensor* _self)
+  , $(int64_t _r)));
+  }|]
+
+combinations_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+combinations_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::combinations(
+    *$(at::Tensor* _self)));
+  }|]
+
+result_type_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (ScalarType)
+result_type_tt _tensor _other =
+  [C.throwBlock| at::ScalarType { return (at::result_type(
+    *$(at::Tensor* _tensor)
+  , *$(at::Tensor* _other)));
+  }|]
+
+result_type_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (ScalarType)
+result_type_ts _tensor _other =
+  [C.throwBlock| at::ScalarType { return (at::result_type(
+    *$(at::Tensor* _tensor)
+  , *$(at::Scalar* _other)));
+  }|]
+
+result_type_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (ScalarType)
+result_type_st _scalar _tensor =
+  [C.throwBlock| at::ScalarType { return (at::result_type(
+    *$(at::Scalar* _scalar)
+  , *$(at::Tensor* _tensor)));
+  }|]
+
+result_type_ss
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> IO (ScalarType)
+result_type_ss _scalar1 _scalar2 =
+  [C.throwBlock| at::ScalarType { return (at::result_type(
+    *$(at::Scalar* _scalar1)
+  , *$(at::Scalar* _scalar2)));
+  }|]
+
+can_cast_ss
+  :: ScalarType
+  -> ScalarType
+  -> IO (CBool)
+can_cast_ss _from _to =
+  [C.throwBlock| bool { return (at::can_cast(
+    $(at::ScalarType _from)
+  , $(at::ScalarType _to)));
+  }|]
+
+promote_types_ss
+  :: ScalarType
+  -> ScalarType
+  -> IO (ScalarType)
+promote_types_ss _type1 _type2 =
+  [C.throwBlock| at::ScalarType { return (at::promote_types(
+    $(at::ScalarType _type1)
+  , $(at::ScalarType _type2)));
+  }|]
+
+_local_scalar_dense_t
+  :: Ptr Tensor
+  -> IO (Ptr Scalar)
+_local_scalar_dense_t _self =
+  [C.throwBlock| at::Scalar* { return new at::Scalar(at::_local_scalar_dense(
+    *$(at::Tensor* _self)));
+  }|]
+
+_lstm_mps_tllbldbbb
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
+_lstm_mps_tllbldbbb _input _hx _params _has_biases _num_layers _dropout _train _bidirectional _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_lstm_mps(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)));
+  }|]
+
+lstm_mps_backward_tttttttllbldbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,TensorList,TensorList)))
+lstm_mps_backward_tttttttllbldbbb _grad_y _grad_hy _grad_cy _z_state _cell_state_fwd _input _layersOutputs _hx _params _has_biases _num_layers _dropout _train _bidirectional _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,std::vector<at::Tensor>,std::vector<at::Tensor>>* { return new std::tuple<at::Tensor,std::vector<at::Tensor>,std::vector<at::Tensor>>(at::lstm_mps_backward(
+    *$(at::Tensor* _grad_y)
+  , *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , *$(at::Tensor* _z_state)
+  , *$(at::Tensor* _cell_state_fwd)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _layersOutputs)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)));
+  }|]
+
+_thnn_fused_lstm_cell_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_ttttt _input_gates _hidden_gates _cx _input_bias _hidden_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell(
+    *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _input_bias)
+  , *$(at::Tensor* _hidden_bias)));
+  }|]
+
+_thnn_fused_lstm_cell_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_tttt _input_gates _hidden_gates _cx _input_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell(
+    *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _input_bias)));
+  }|]
+
+_thnn_fused_lstm_cell_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_ttt _input_gates _hidden_gates _cx =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell(
+    *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _cx)));
+  }|]
+
+_thnn_fused_lstm_cell_backward_impl_tttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_backward_impl_tttttb _grad_hy _grad_cy _cx _cy _workspace _has_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_backward_impl(
+    *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _cy)
+  , *$(at::Tensor* _workspace)
+  , $(bool _has_bias)));
+  }|]
+
+_thnn_fused_lstm_cell_backward_tttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_fused_lstm_cell_backward_tttttb _grad_hy _grad_cy _cx _cy _workspace _has_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_backward(
+    *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _cy)
+  , *$(at::Tensor* _workspace)
+  , $(bool _has_bias)));
+  }|]
+
+_thnn_differentiable_lstm_cell_backward_tttttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_differentiable_lstm_cell_backward_tttttttt _grad_hy _grad_cy _input_gates _hidden_gates _input_bias _hidden_bias _cx _cy =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_thnn_differentiable_lstm_cell_backward(
+    *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _grad_cy)
+  , *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _input_bias)
+  , *$(at::Tensor* _hidden_bias)
+  , *$(at::Tensor* _cx)
+  , *$(at::Tensor* _cy)));
+  }|]
+
+_thnn_fused_gru_cell_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_ttttt _input_gates _hidden_gates _hx _input_bias _hidden_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell(
+    *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _input_bias)
+  , *$(at::Tensor* _hidden_bias)));
+  }|]
+
+_thnn_fused_gru_cell_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_tttt _input_gates _hidden_gates _hx _input_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell(
+    *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _input_bias)));
+  }|]
+
+_thnn_fused_gru_cell_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_thnn_fused_gru_cell_ttt _input_gates _hidden_gates _hx =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell(
+    *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _hx)));
+  }|]
+
+_thnn_fused_gru_cell_backward_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_fused_gru_cell_backward_ttb _grad_hy _workspace _has_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell_backward(
+    *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _workspace)
+  , $(bool _has_bias)));
+  }|]
+
+_thnn_differentiable_gru_cell_backward_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
+_thnn_differentiable_gru_cell_backward_tttttt _grad_hy _input_gates _hidden_gates _hx _input_bias _hidden_bias =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_thnn_differentiable_gru_cell_backward(
+    *$(at::Tensor* _grad_hy)
+  , *$(at::Tensor* _input_gates)
+  , *$(at::Tensor* _hidden_gates)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _input_bias)
+  , *$(at::Tensor* _hidden_bias)));
+  }|]
+
+lstm_tllbldbbb
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+lstm_tllbldbbb _input _hx _params _has_biases _num_layers _dropout _train _bidirectional _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::lstm(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)));
+  }|]
+
+lstm_ttllbldbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+lstm_ttllbldbb _data _batch_sizes _hx _params _has_biases _num_layers _dropout _train _bidirectional =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::lstm(
+    *$(at::Tensor* _data)
+  , *$(at::Tensor* _batch_sizes)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)));
+  }|]
+
+gru_ttlbldbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+gru_ttlbldbbb _input _hx _params _has_biases _num_layers _dropout _train _bidirectional _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::gru(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)));
+  }|]
+
+gru_tttlbldbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+gru_tttlbldbb _data _batch_sizes _hx _params _has_biases _num_layers _dropout _train _bidirectional =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::gru(
+    *$(at::Tensor* _data)
+  , *$(at::Tensor* _batch_sizes)
+  , *$(at::Tensor* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)));
+  }|]
+
+rnn_tanh_ttlbldbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+rnn_tanh_ttlbldbbb _input _hx _params _has_biases _num_layers _dropout _train _bidirectional _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::rnn_tanh(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)));
+  }|]
+
+rnn_tanh_tttlbldbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+rnn_tanh_tttlbldbb _data _batch_sizes _hx _params _has_biases _num_layers _dropout _train _bidirectional =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::rnn_tanh(
+    *$(at::Tensor* _data)
+  , *$(at::Tensor* _batch_sizes)
+  , *$(at::Tensor* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)));
+  }|]
+
+rnn_relu_ttlbldbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+rnn_relu_ttlbldbbb _input _hx _params _has_biases _num_layers _dropout _train _bidirectional _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::rnn_relu(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)
+  , $(bool _batch_first)));
+  }|]
+
+rnn_relu_tttlbldbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorList
+  -> CBool
+  -> Int64
+  -> CDouble
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+rnn_relu_tttlbldbb _data _batch_sizes _hx _params _has_biases _num_layers _dropout _train _bidirectional =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::rnn_relu(
+    *$(at::Tensor* _data)
+  , *$(at::Tensor* _batch_sizes)
+  , *$(at::Tensor* _hx)
+  , *$(std::vector<at::Tensor>* _params)
+  , $(bool _has_biases)
+  , $(int64_t _num_layers)
+  , $(double _dropout)
+  , $(bool _train)
+  , $(bool _bidirectional)));
+  }|]
+
+lstm_cell_tltttt
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+lstm_cell_tltttt _input _hx _w_ih _w_hh _b_ih _b_hh =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::lstm_cell(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)
+  , *$(at::Tensor* _b_hh)));
+  }|]
+
+lstm_cell_tlttt
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+lstm_cell_tlttt _input _hx _w_ih _w_hh _b_ih =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::lstm_cell(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)));
+  }|]
+
+lstm_cell_tltt
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+lstm_cell_tltt _input _hx _w_ih _w_hh =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::lstm_cell(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)));
+  }|]
+
+gru_cell_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gru_cell_tttttt _input _hx _w_ih _w_hh _b_ih _b_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gru_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)
+  , *$(at::Tensor* _b_hh)));
+  }|]
+
+gru_cell_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gru_cell_ttttt _input _hx _w_ih _w_hh _b_ih =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gru_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)));
+  }|]
+
+gru_cell_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gru_cell_tttt _input _hx _w_ih _w_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gru_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)));
+  }|]
+
+rnn_tanh_cell_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rnn_tanh_cell_tttttt _input _hx _w_ih _w_hh _b_ih _b_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rnn_tanh_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)
+  , *$(at::Tensor* _b_hh)));
+  }|]
+
+rnn_tanh_cell_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rnn_tanh_cell_ttttt _input _hx _w_ih _w_hh _b_ih =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rnn_tanh_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)));
+  }|]
+
+rnn_tanh_cell_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rnn_tanh_cell_tttt _input _hx _w_ih _w_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rnn_tanh_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)));
+  }|]
+
+rnn_relu_cell_tttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rnn_relu_cell_tttttt _input _hx _w_ih _w_hh _b_ih _b_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rnn_relu_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)
+  , *$(at::Tensor* _b_hh)));
+  }|]
+
+rnn_relu_cell_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rnn_relu_cell_ttttt _input _hx _w_ih _w_hh _b_ih =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rnn_relu_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)));
+  }|]
+
+rnn_relu_cell_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rnn_relu_cell_tttt _input _hx _w_ih _w_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rnn_relu_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)));
+  }|]
+
+quantized_lstm_cell_tlttttttttssss
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+quantized_lstm_cell_tlttttttttssss _input _hx _w_ih _w_hh _b_ih _b_hh _packed_ih _packed_hh _col_offsets_ih _col_offsets_hh _scale_ih _scale_hh _zero_point_ih _zero_point_hh =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::quantized_lstm_cell(
+    *$(at::Tensor* _input)
+  , *$(std::vector<at::Tensor>* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)
+  , *$(at::Tensor* _b_hh)
+  , *$(at::Tensor* _packed_ih)
+  , *$(at::Tensor* _packed_hh)
+  , *$(at::Tensor* _col_offsets_ih)
+  , *$(at::Tensor* _col_offsets_hh)
+  , *$(at::Scalar* _scale_ih)
+  , *$(at::Scalar* _scale_hh)
+  , *$(at::Scalar* _zero_point_ih)
+  , *$(at::Scalar* _zero_point_hh)));
+  }|]
+
+quantized_gru_cell_ttttttttttssss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+quantized_gru_cell_ttttttttttssss _input _hx _w_ih _w_hh _b_ih _b_hh _packed_ih _packed_hh _col_offsets_ih _col_offsets_hh _scale_ih _scale_hh _zero_point_ih _zero_point_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_gru_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)
+  , *$(at::Tensor* _b_hh)
+  , *$(at::Tensor* _packed_ih)
+  , *$(at::Tensor* _packed_hh)
+  , *$(at::Tensor* _col_offsets_ih)
+  , *$(at::Tensor* _col_offsets_hh)
+  , *$(at::Scalar* _scale_ih)
+  , *$(at::Scalar* _scale_hh)
+  , *$(at::Scalar* _zero_point_ih)
+  , *$(at::Scalar* _zero_point_hh)));
+  }|]
+
+quantized_rnn_relu_cell_ttttttttttssss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+quantized_rnn_relu_cell_ttttttttttssss _input _hx _w_ih _w_hh _b_ih _b_hh _packed_ih _packed_hh _col_offsets_ih _col_offsets_hh _scale_ih _scale_hh _zero_point_ih _zero_point_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_rnn_relu_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)
+  , *$(at::Tensor* _b_hh)
+  , *$(at::Tensor* _packed_ih)
+  , *$(at::Tensor* _packed_hh)
+  , *$(at::Tensor* _col_offsets_ih)
+  , *$(at::Tensor* _col_offsets_hh)
+  , *$(at::Scalar* _scale_ih)
+  , *$(at::Scalar* _scale_hh)
+  , *$(at::Scalar* _zero_point_ih)
+  , *$(at::Scalar* _zero_point_hh)));
+  }|]
+
+quantized_rnn_tanh_cell_ttttttttttssss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+quantized_rnn_tanh_cell_ttttttttttssss _input _hx _w_ih _w_hh _b_ih _b_hh _packed_ih _packed_hh _col_offsets_ih _col_offsets_hh _scale_ih _scale_hh _zero_point_ih _zero_point_hh =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_rnn_tanh_cell(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _hx)
+  , *$(at::Tensor* _w_ih)
+  , *$(at::Tensor* _w_hh)
+  , *$(at::Tensor* _b_ih)
+  , *$(at::Tensor* _b_hh)
+  , *$(at::Tensor* _packed_ih)
+  , *$(at::Tensor* _packed_hh)
+  , *$(at::Tensor* _col_offsets_ih)
+  , *$(at::Tensor* _col_offsets_hh)
+  , *$(at::Scalar* _scale_ih)
+  , *$(at::Scalar* _scale_hh)
+  , *$(at::Scalar* _zero_point_ih)
+  , *$(at::Scalar* _zero_point_hh)));
+  }|]
+
+_pack_padded_sequence_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_pack_padded_sequence_ttb _input _lengths _batch_first =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_pack_padded_sequence(
+    *$(at::Tensor* _input)
+  , *$(at::Tensor* _lengths)
+  , $(bool _batch_first)));
+  }|]
+
+_pack_padded_sequence_backward_tltb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_pack_padded_sequence_backward_tltb _grad _input_size _batch_sizes _batch_first =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pack_padded_sequence_backward(
+    *$(at::Tensor* _grad)
+  , *$(std::vector<int64_t>* _input_size)
+  , *$(at::Tensor* _batch_sizes)
+  , $(bool _batch_first)));
+  }|]
+
+_pad_packed_sequence_ttbsl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+_pad_packed_sequence_ttbsl _data _batch_sizes _batch_first _padding_value _total_length =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_pad_packed_sequence(
+    *$(at::Tensor* _data)
+  , *$(at::Tensor* _batch_sizes)
+  , $(bool _batch_first)
+  , *$(at::Scalar* _padding_value)
+  , $(int64_t _total_length)));
+  }|]
+
+lift_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+lift_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lift(
+    *$(at::Tensor* _self)));
+  }|]
+
+lift_fresh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+lift_fresh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lift_fresh(
+    *$(at::Tensor* _self)));
+  }|]
+
+lift_fresh_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+lift_fresh_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lift_fresh_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+masked_fill_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+masked_fill_tts _self _mask _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_fill(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , *$(at::Scalar* _value)));
+  }|]
+
+masked_fill_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+masked_fill_ttt _self _mask _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_fill(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , *$(at::Tensor* _value)));
+  }|]
+
+masked_scatter_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+masked_scatter_ttt _self _mask _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , *$(at::Tensor* _source)));
+  }|]
+
+_masked_softmax_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+_masked_softmax_ttll _self _mask _dim _mask_type =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , $(int64_t _dim)
+  , $(int64_t _mask_type)));
+  }|]
+
+_masked_softmax_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_masked_softmax_ttl _self _mask _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)
+  , $(int64_t _dim)));
+  }|]
+
+_masked_softmax_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_masked_softmax_tt _self _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+_masked_softmax_backward_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_masked_softmax_backward_tttl _grad_output _output _mask _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _mask)
+  , $(int64_t _dim)));
+  }|]
+
+_masked_softmax_backward_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_masked_softmax_backward_ttt _grad_output _output _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _output)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+put_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+put_tttb _self _index _source _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::put(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , $(bool _accumulate)));
+  }|]
+
+put_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+put_ttt _self _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::put(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+index_add_out_ttltts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+index_add_out_ttltts _out _self _dim _index _source _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_add_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+index_add_out_ttltt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_add_out_ttltt _out _self _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_add_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+index_add_tltts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+index_add_tltts _self _dim _index _source _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_add(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+index_add_tltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_add_tltt _self _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_add(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+index_add_tntts
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+index_add_tntts _self _dim _index _source _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_add(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+index_add_tntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_add_tntt _self _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_add(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+index_reduce_out_ttlttsb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+index_reduce_out_ttlttsb _out _self _dim _index _source _reduce _include_self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(std::string* _reduce)
+  , $(bool _include_self)));
+  }|]
+
+index_reduce_out_ttltts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+index_reduce_out_ttltts _out _self _dim _index _source _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(std::string* _reduce)));
+  }|]
+
+index_reduce_tlttsb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+index_reduce_tlttsb _self _dim _index _source _reduce _include_self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_reduce(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(std::string* _reduce)
+  , $(bool _include_self)));
+  }|]
+
+index_reduce_tltts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+index_reduce_tltts _self _dim _index _source _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_reduce(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(std::string* _reduce)));
+  }|]
+
+index_fill_tlts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+index_fill_tlts _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_fill(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+index_fill_tltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_fill_tltt _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_fill(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _value)));
+  }|]
+
+index_fill_tnts
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+index_fill_tnts _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_fill(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+index_fill_tntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_fill_tntt _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_fill(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _value)));
+  }|]
+
+scatter_tltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+scatter_tltt _self _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+scatter_out_ttltt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+scatter_out_ttltt _out _self _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+scatter_tlts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+scatter_tlts _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+scatter_out_ttlts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+scatter_out_ttlts _out _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+scatter_tltts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+scatter_tltts _self _dim _index _src _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)));
+  }|]
+
+scatter_out_ttltts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+scatter_out_ttltts _out _self _dim _index _src _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)));
+  }|]
+
+scatter_tltss
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+scatter_tltss _self _dim _index _value _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)
+  , *$(std::string* _reduce)));
+  }|]
+
+scatter_out_ttltss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+scatter_out_ttltss _out _self _dim _index _value _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)
+  , *$(std::string* _reduce)));
+  }|]
+
+scatter_tntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+scatter_tntt _self _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+scatter_tnts
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+scatter_tnts _self _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+scatter_add_tltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+scatter_add_tltt _self _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_add(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+scatter_add_out_ttltt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+scatter_add_out_ttltt _out _self _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_add_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+scatter_add_tntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+scatter_add_tntt _self _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_add(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+scatter_reduce_tlttsb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+scatter_reduce_tlttsb _self _dim _index _src _reduce _include_self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_reduce(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)
+  , $(bool _include_self)));
+  }|]
+
+scatter_reduce_tltts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+scatter_reduce_tltts _self _dim _index _src _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_reduce(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)));
+  }|]
+
+scatter_reduce_out_ttlttsb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+scatter_reduce_out_ttlttsb _out _self _dim _index _src _reduce _include_self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)
+  , $(bool _include_self)));
+  }|]
+
+scatter_reduce_out_ttltts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+scatter_reduce_out_ttltts _out _self _dim _index _src _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scatter_reduce_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)));
+  }|]
+
+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_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_and_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_and(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _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
+  -> IO (Ptr Tensor)
+__and___ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__and__(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+__and___tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+__and___tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__and__(
+    *$(at::Tensor* _self)
+  , *$(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_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_or_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_or(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _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
+  -> IO (Ptr Tensor)
+__or___ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__or__(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+__or___tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+__or___tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__or__(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_xor_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_xor_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_xor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_xor_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_xor_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_xor_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_xor_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_xor_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_xor(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_xor_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_xor_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_xor(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_xor_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_xor_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_xor(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+__xor___ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+__xor___ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__xor__(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+__xor___tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+__xor___tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__xor__(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+__lshift___ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+__lshift___ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__lshift__(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+__lshift___tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+__lshift___tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__lshift__(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_left_shift_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_left_shift_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_left_shift(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_left_shift_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_left_shift_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_left_shift_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_left_shift_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_left_shift_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_left_shift(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_left_shift_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_left_shift_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_left_shift_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_left_shift_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_left_shift_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_left_shift(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+__rshift___ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+__rshift___ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__rshift__(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+__rshift___tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+__rshift___tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::__rshift__(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_right_shift_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_right_shift_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_right_shift(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_right_shift_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_right_shift_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_right_shift_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+bitwise_right_shift_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_right_shift_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_right_shift(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_right_shift_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+bitwise_right_shift_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_right_shift_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+bitwise_right_shift_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bitwise_right_shift_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bitwise_right_shift(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+addbmm_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addbmm_out_ttttss _out _self _batch1 _batch2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addbmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addbmm_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addbmm_out_tttts _out _self _batch1 _batch2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addbmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addbmm_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addbmm_out_tttt _out _self _batch1 _batch2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addbmm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)));
+  }|]
+
+addbmm_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addbmm_tttss _self _batch1 _batch2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addbmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+addbmm_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addbmm_ttts _self _batch1 _batch2 _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addbmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+addbmm_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addbmm_ttt _self _batch1 _batch2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addbmm(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)));
+  }|]
+
+diag_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diag_out_ttl _out _self _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _diagonal)));
+  }|]
+
+diag_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+diag_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+diag_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+diag_tl _self _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag(
+    *$(at::Tensor* _self)
+  , $(int64_t _diagonal)));
+  }|]
+
+diag_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+diag_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diag(
+    *$(at::Tensor* _self)));
+  }|]
+
+cross_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cross_out_tttl _out _self _other _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(int64_t _dim)));
+  }|]
+
+cross_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cross_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+cross_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cross_ttl _self _other _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , $(int64_t _dim)));
+  }|]
+
+cross_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cross_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+triu_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+triu_out_ttl _out _self _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _diagonal)));
+  }|]
+
+triu_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+triu_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+triu_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+triu_tl _self _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu(
+    *$(at::Tensor* _self)
+  , $(int64_t _diagonal)));
+  }|]
+
+triu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+triu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu(
+    *$(at::Tensor* _self)));
+  }|]
+
+tril_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tril_out_ttl _out _self _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _diagonal)));
+  }|]
+
+tril_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tril_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+tril_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tril_tl _self _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril(
+    *$(at::Tensor* _self)
+  , $(int64_t _diagonal)));
+  }|]
+
+tril_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tril_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril(
+    *$(at::Tensor* _self)));
+  }|]
+
+tril_indices_lllo
+  :: Int64
+  -> Int64
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+tril_indices_lllo _row _col _offset _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril_indices(
+    $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+tril_indices_lll
+  :: Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tril_indices_lll _row _col _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril_indices(
+    $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)));
+  }|]
+
+tril_indices_ll
+  :: Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tril_indices_ll _row _col =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::tril_indices(
+    $(int64_t _row)
+  , $(int64_t _col)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native7.hs b/src/Torch/Internal/Unmanaged/Native/Native7.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native7.hs
@@ -0,0 +1,3496 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native7 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+triu_indices_lllo
+  :: Int64
+  -> Int64
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+triu_indices_lllo _row _col _offset _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu_indices(
+    $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+triu_indices_lll
+  :: Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+triu_indices_lll _row _col _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu_indices(
+    $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)));
+  }|]
+
+triu_indices_ll
+  :: Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+triu_indices_ll _row _col =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::triu_indices(
+    $(int64_t _row)
+  , $(int64_t _col)));
+  }|]
+
+trace_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+trace_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trace(
+    *$(at::Tensor* _self)));
+  }|]
+
+trace_backward_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+trace_backward_tl _grad _sizes =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::trace_backward(
+    *$(at::Tensor* _grad)
+  , *$(std::vector<int64_t>* _sizes)));
+  }|]
+
+ne_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+ne_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ne_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+ne_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+ne_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ne(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+ne_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ne_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ne_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+ne_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ne_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ne(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+not_equal_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+not_equal_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::not_equal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+not_equal_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+not_equal_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::not_equal(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+not_equal_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+not_equal_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::not_equal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+not_equal_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+not_equal_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::not_equal(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+eq_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+eq_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eq_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+eq_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+eq_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eq(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+eq_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+eq_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eq_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+eq_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+eq_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::eq(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+ge_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+ge_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ge_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+ge_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+ge_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ge(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+ge_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ge_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ge_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+ge_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ge_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ge(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+greater_equal_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+greater_equal_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::greater_equal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+greater_equal_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+greater_equal_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::greater_equal(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+greater_equal_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+greater_equal_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::greater_equal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+greater_equal_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+greater_equal_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::greater_equal(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+le_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+le_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::le_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+le_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+le_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::le(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+le_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+le_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::le_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+le_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+le_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::le(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+less_equal_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+less_equal_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::less_equal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+less_equal_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+less_equal_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::less_equal(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+less_equal_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+less_equal_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::less_equal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+less_equal_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+less_equal_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::less_equal(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+gt_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+gt_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gt_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+gt_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+gt_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gt(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+gt_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gt_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gt_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+gt_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gt_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gt(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+greater_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+greater_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::greater_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+greater_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+greater_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::greater(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+greater_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+greater_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::greater_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+greater_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+greater_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::greater(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+lt_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+lt_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lt_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+lt_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+lt_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lt(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+lt_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lt_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lt_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+lt_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lt_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lt(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+less_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+less_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::less_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+less_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+less_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::less(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+less_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+less_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::less_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+less_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+less_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::less(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+take_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+take_out_ttt _out _self _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::take_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _index)));
+  }|]
+
+take_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+take_tt _self _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::take(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _index)));
+  }|]
+
+take_along_dim_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+take_along_dim_out_tttl _out _self _indices _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::take_along_dim_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _dim)));
+  }|]
+
+take_along_dim_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+take_along_dim_out_ttt _out _self _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::take_along_dim_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+take_along_dim_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+take_along_dim_ttl _self _indices _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::take_along_dim(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , $(int64_t _dim)));
+  }|]
+
+take_along_dim_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+take_along_dim_tt _self _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::take_along_dim(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+index_select_out_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_select_out_ttlt _out _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_select_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+index_select_tlt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_select_tlt _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_select(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+index_select_out_ttnt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_select_out_ttnt _out _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_select_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+index_select_tnt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_select_tnt _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_select(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+index_select_backward_tllt
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+index_select_backward_tllt _grad _self_sizes _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::index_select_backward(
+    *$(at::Tensor* _grad)
+  , *$(std::vector<int64_t>* _self_sizes)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+masked_select_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+masked_select_out_ttt _out _self _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_select_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+masked_select_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+masked_select_tt _self _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_select(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+masked_select_backward_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+masked_select_backward_ttt _grad _input _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_select_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _input)
+  , *$(at::Tensor* _mask)));
+  }|]
+
+nonzero_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nonzero_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nonzero_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+nonzero_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+nonzero_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nonzero(
+    *$(at::Tensor* _self)));
+  }|]
+
+nonzero_numpy_t
+  :: Ptr Tensor
+  -> IO (Ptr TensorList)
+nonzero_numpy_t _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::nonzero_numpy(
+    *$(at::Tensor* _self)));
+  }|]
+
+argwhere_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+argwhere_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argwhere(
+    *$(at::Tensor* _self)));
+  }|]
+
+gather_out_ttltb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+gather_out_ttltb _out _self _dim _index _sparse_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , $(bool _sparse_grad)));
+  }|]
+
+gather_out_ttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gather_out_ttlt _out _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+gather_tltb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+gather_tltb _self _dim _index _sparse_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , $(bool _sparse_grad)));
+  }|]
+
+gather_tlt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gather_tlt _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+gather_backward_ttltb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+gather_backward_ttltb _grad _self _dim _index _sparse_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather_backward(
+    *$(at::Tensor* _grad)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , $(bool _sparse_grad)));
+  }|]
+
+gather_out_ttntb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+gather_out_ttntb _out _self _dim _index _sparse_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , $(bool _sparse_grad)));
+  }|]
+
+gather_out_ttnt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gather_out_ttnt _out _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+gather_tntb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+gather_tntb _self _dim _index _sparse_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , $(bool _sparse_grad)));
+  }|]
+
+gather_tnt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+gather_tnt _self _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::gather(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+_gather_sparse_backward_tltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_gather_sparse_backward_tltt _self _dim _index _grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_gather_sparse_backward(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _grad)));
+  }|]
+
+addcmul_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addcmul_out_tttts _out _self _tensor1 _tensor2 _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addcmul_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+addcmul_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addcmul_out_tttt _out _self _tensor1 _tensor2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addcmul_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)));
+  }|]
+
+addcmul_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addcmul_ttts _self _tensor1 _tensor2 _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addcmul(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+addcmul_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addcmul_ttt _self _tensor1 _tensor2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addcmul(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)));
+  }|]
+
+addcdiv_out_tttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addcdiv_out_tttts _out _self _tensor1 _tensor2 _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addcdiv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+addcdiv_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addcdiv_out_tttt _out _self _tensor1 _tensor2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addcdiv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)));
+  }|]
+
+addcdiv_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+addcdiv_ttts _self _tensor1 _tensor2 _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addcdiv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+addcdiv_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+addcdiv_ttt _self _tensor1 _tensor2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addcdiv(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)));
+  }|]
+
+cross_entropy_loss_tttlld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+cross_entropy_loss_tttlld _self _target _weight _reduction _ignore_index _label_smoothing =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross_entropy_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)
+  , $(double _label_smoothing)));
+  }|]
+
+cross_entropy_loss_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+cross_entropy_loss_tttll _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross_entropy_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+cross_entropy_loss_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+cross_entropy_loss_tttl _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross_entropy_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+cross_entropy_loss_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cross_entropy_loss_ttt _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross_entropy_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+cross_entropy_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cross_entropy_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cross_entropy_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+triangular_solve_out_ttttbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+triangular_solve_out_ttttbbb _X _M _self _A _upper _transpose _unitriangular =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::triangular_solve_out(
+    *$(at::Tensor* _X)
+  , *$(at::Tensor* _M)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)
+  , $(bool _upper)
+  , $(bool _transpose)
+  , $(bool _unitriangular)));
+  }|]
+
+triangular_solve_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+triangular_solve_out_ttttbb _X _M _self _A _upper _transpose =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::triangular_solve_out(
+    *$(at::Tensor* _X)
+  , *$(at::Tensor* _M)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)
+  , $(bool _upper)
+  , $(bool _transpose)));
+  }|]
+
+triangular_solve_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+triangular_solve_out_ttttb _X _M _self _A _upper =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::triangular_solve_out(
+    *$(at::Tensor* _X)
+  , *$(at::Tensor* _M)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)
+  , $(bool _upper)));
+  }|]
+
+triangular_solve_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+triangular_solve_out_tttt _X _M _self _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::triangular_solve_out(
+    *$(at::Tensor* _X)
+  , *$(at::Tensor* _M)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)));
+  }|]
+
+triangular_solve_ttbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+triangular_solve_ttbbb _self _A _upper _transpose _unitriangular =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::triangular_solve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)
+  , $(bool _upper)
+  , $(bool _transpose)
+  , $(bool _unitriangular)));
+  }|]
+
+triangular_solve_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+triangular_solve_ttbb _self _A _upper _transpose =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::triangular_solve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)
+  , $(bool _upper)
+  , $(bool _transpose)));
+  }|]
+
+triangular_solve_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+triangular_solve_ttb _self _A _upper =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::triangular_solve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)
+  , $(bool _upper)));
+  }|]
+
+triangular_solve_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+triangular_solve_tt _self _A =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::triangular_solve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)));
+  }|]
+
+_linalg_check_errors_tsb
+  :: Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (())
+_linalg_check_errors_tsb _info _api_name _is_matrix =
+  [C.throwBlock| void {  (at::_linalg_check_errors(
+    *$(at::Tensor* _info)
+  , *$(std::string* _api_name)
+  , $(bool _is_matrix)));
+  }|]
+
+linalg_solve_triangular_out_tttbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_solve_triangular_out_tttbbb _out _self _B _upper _left _unitriangular =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_triangular_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _B)
+  , $(bool _upper)
+  , $(bool _left)
+  , $(bool _unitriangular)));
+  }|]
+
+linalg_solve_triangular_out_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_solve_triangular_out_tttbb _out _self _B _upper _left =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_triangular_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _B)
+  , $(bool _upper)
+  , $(bool _left)));
+  }|]
+
+linalg_solve_triangular_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_solve_triangular_out_tttb _out _self _B _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_triangular_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _B)
+  , $(bool _upper)));
+  }|]
+
+linalg_solve_triangular_ttbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_solve_triangular_ttbbb _self _B _upper _left _unitriangular =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_triangular(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _B)
+  , $(bool _upper)
+  , $(bool _left)
+  , $(bool _unitriangular)));
+  }|]
+
+linalg_solve_triangular_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_solve_triangular_ttbb _self _B _upper _left =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_triangular(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _B)
+  , $(bool _upper)
+  , $(bool _left)));
+  }|]
+
+linalg_solve_triangular_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+linalg_solve_triangular_ttb _self _B _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_triangular(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _B)
+  , $(bool _upper)));
+  }|]
+
+linalg_vander_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+linalg_vander_tl _x _N =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vander(
+    *$(at::Tensor* _x)
+  , $(int64_t _N)));
+  }|]
+
+linalg_vander_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+linalg_vander_t _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_vander(
+    *$(at::Tensor* _x)));
+  }|]
+
+svd_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_out_ttttbb _U _S _V _self _some _compute_uv =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _V)
+  , *$(at::Tensor* _self)
+  , $(bool _some)
+  , $(bool _compute_uv)));
+  }|]
+
+svd_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_out_ttttb _U _S _V _self _some =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _V)
+  , *$(at::Tensor* _self)
+  , $(bool _some)));
+  }|]
+
+svd_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_out_tttt _U _S _V _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::svd_out(
+    *$(at::Tensor* _U)
+  , *$(at::Tensor* _S)
+  , *$(at::Tensor* _V)
+  , *$(at::Tensor* _self)));
+  }|]
+
+svd_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_tbb _self _some _compute_uv =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::svd(
+    *$(at::Tensor* _self)
+  , $(bool _some)
+  , $(bool _compute_uv)));
+  }|]
+
+svd_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_tb _self _some =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::svd(
+    *$(at::Tensor* _self)
+  , $(bool _some)));
+  }|]
+
+svd_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+svd_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::svd(
+    *$(at::Tensor* _self)));
+  }|]
+
+swapaxes_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+swapaxes_tll _self _axis0 _axis1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::swapaxes(
+    *$(at::Tensor* _self)
+  , $(int64_t _axis0)
+  , $(int64_t _axis1)));
+  }|]
+
+swapdims_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+swapdims_tll _self _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::swapdims(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+cholesky_out_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+cholesky_out_ttb _out _self _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _upper)));
+  }|]
+
+cholesky_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cholesky_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+cholesky_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+cholesky_tb _self _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky(
+    *$(at::Tensor* _self)
+  , $(bool _upper)));
+  }|]
+
+cholesky_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cholesky_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky(
+    *$(at::Tensor* _self)));
+  }|]
+
+cholesky_solve_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+cholesky_solve_out_tttb _out _self _input2 _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)
+  , $(bool _upper)));
+  }|]
+
+cholesky_solve_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cholesky_solve_out_ttt _out _self _input2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)));
+  }|]
+
+cholesky_solve_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+cholesky_solve_ttb _self _input2 _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_solve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)
+  , $(bool _upper)));
+  }|]
+
+cholesky_solve_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cholesky_solve_tt _self _input2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_solve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)));
+  }|]
+
+_cholesky_solve_helper_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_cholesky_solve_helper_ttb _self _A _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cholesky_solve_helper(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _A)
+  , $(bool _upper)));
+  }|]
+
+cholesky_inverse_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+cholesky_inverse_tb _self _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_inverse(
+    *$(at::Tensor* _self)
+  , $(bool _upper)));
+  }|]
+
+cholesky_inverse_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+cholesky_inverse_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_inverse(
+    *$(at::Tensor* _self)));
+  }|]
+
+cholesky_inverse_out_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+cholesky_inverse_out_ttb _out _self _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_inverse_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(bool _upper)));
+  }|]
+
+cholesky_inverse_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+cholesky_inverse_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::cholesky_inverse_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+qr_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+qr_out_tttb _Q _R _self _some =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::qr_out(
+    *$(at::Tensor* _Q)
+  , *$(at::Tensor* _R)
+  , *$(at::Tensor* _self)
+  , $(bool _some)));
+  }|]
+
+qr_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+qr_out_ttt _Q _R _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::qr_out(
+    *$(at::Tensor* _Q)
+  , *$(at::Tensor* _R)
+  , *$(at::Tensor* _self)));
+  }|]
+
+qr_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+qr_tb _self _some =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::qr(
+    *$(at::Tensor* _self)
+  , $(bool _some)));
+  }|]
+
+qr_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+qr_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::qr(
+    *$(at::Tensor* _self)));
+  }|]
+
+geqrf_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+geqrf_out_ttt _a _tau _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::geqrf_out(
+    *$(at::Tensor* _a)
+  , *$(at::Tensor* _tau)
+  , *$(at::Tensor* _self)));
+  }|]
+
+geqrf_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+geqrf_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::geqrf(
+    *$(at::Tensor* _self)));
+  }|]
+
+orgqr_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+orgqr_tt _self _input2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::orgqr(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)));
+  }|]
+
+orgqr_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+orgqr_out_ttt _out _self _input2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::orgqr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)));
+  }|]
+
+ormqr_out_ttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+ormqr_out_ttttbb _out _self _input2 _input3 _left _transpose =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ormqr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _input3)
+  , $(bool _left)
+  , $(bool _transpose)));
+  }|]
+
+ormqr_out_ttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+ormqr_out_ttttb _out _self _input2 _input3 _left =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ormqr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _input3)
+  , $(bool _left)));
+  }|]
+
+ormqr_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ormqr_out_tttt _out _self _input2 _input3 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ormqr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _input3)));
+  }|]
+
+ormqr_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+ormqr_tttbb _self _input2 _input3 _left _transpose =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ormqr(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _input3)
+  , $(bool _left)
+  , $(bool _transpose)));
+  }|]
+
+ormqr_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+ormqr_tttb _self _input2 _input3 _left =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ormqr(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _input3)
+  , $(bool _left)));
+  }|]
+
+ormqr_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+ormqr_ttt _self _input2 _input3 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ormqr(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _input2)
+  , *$(at::Tensor* _input3)));
+  }|]
+
+_lu_with_info_tbb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_lu_with_info_tbb _self _pivot _check_errors =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_lu_with_info(
+    *$(at::Tensor* _self)
+  , $(bool _pivot)
+  , $(bool _check_errors)));
+  }|]
+
+_lu_with_info_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_lu_with_info_tb _self _pivot =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_lu_with_info(
+    *$(at::Tensor* _self)
+  , $(bool _pivot)));
+  }|]
+
+_lu_with_info_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+_lu_with_info_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_lu_with_info(
+    *$(at::Tensor* _self)));
+  }|]
+
+lu_solve_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lu_solve_out_tttt _out _self _LU_data _LU_pivots =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lu_solve_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)));
+  }|]
+
+lu_solve_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lu_solve_ttt _self _LU_data _LU_pivots =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lu_solve(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)));
+  }|]
+
+lu_unpack_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_ttbb _LU_data _LU_pivots _unpack_data _unpack_pivots =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::lu_unpack(
+    *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)
+  , $(bool _unpack_data)
+  , $(bool _unpack_pivots)));
+  }|]
+
+lu_unpack_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_ttb _LU_data _LU_pivots _unpack_data =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::lu_unpack(
+    *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)
+  , $(bool _unpack_data)));
+  }|]
+
+lu_unpack_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_tt _LU_data _LU_pivots =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::lu_unpack(
+    *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)));
+  }|]
+
+lu_unpack_out_tttttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_out_tttttbb _P _L _U _LU_data _LU_pivots _unpack_data _unpack_pivots =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::lu_unpack_out(
+    *$(at::Tensor* _P)
+  , *$(at::Tensor* _L)
+  , *$(at::Tensor* _U)
+  , *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)
+  , $(bool _unpack_data)
+  , $(bool _unpack_pivots)));
+  }|]
+
+lu_unpack_out_tttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_out_tttttb _P _L _U _LU_data _LU_pivots _unpack_data =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::lu_unpack_out(
+    *$(at::Tensor* _P)
+  , *$(at::Tensor* _L)
+  , *$(at::Tensor* _U)
+  , *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)
+  , $(bool _unpack_data)));
+  }|]
+
+lu_unpack_out_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+lu_unpack_out_ttttt _P _L _U _LU_data _LU_pivots =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::lu_unpack_out(
+    *$(at::Tensor* _P)
+  , *$(at::Tensor* _L)
+  , *$(at::Tensor* _U)
+  , *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)));
+  }|]
+
+multinomial_out_ttlbG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+multinomial_out_ttlbG _out _self _num_samples _replacement _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multinomial_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _num_samples)
+  , $(bool _replacement)
+  , *$(at::Generator* _generator)));
+  }|]
+
+multinomial_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+multinomial_out_ttlb _out _self _num_samples _replacement =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multinomial_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _num_samples)
+  , $(bool _replacement)));
+  }|]
+
+multinomial_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+multinomial_out_ttl _out _self _num_samples =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multinomial_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _num_samples)));
+  }|]
+
+multinomial_tlbG
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+multinomial_tlbG _self _num_samples _replacement _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multinomial(
+    *$(at::Tensor* _self)
+  , $(int64_t _num_samples)
+  , $(bool _replacement)
+  , *$(at::Generator* _generator)));
+  }|]
+
+multinomial_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+multinomial_tlb _self _num_samples _replacement =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multinomial(
+    *$(at::Tensor* _self)
+  , $(int64_t _num_samples)
+  , $(bool _replacement)));
+  }|]
+
+multinomial_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+multinomial_tl _self _num_samples =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multinomial(
+    *$(at::Tensor* _self)
+  , $(int64_t _num_samples)));
+  }|]
+
+lgamma_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lgamma_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lgamma_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+lgamma_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+lgamma_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lgamma(
+    *$(at::Tensor* _self)));
+  }|]
+
+digamma_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+digamma_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::digamma_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+digamma_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+digamma_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::digamma(
+    *$(at::Tensor* _self)));
+  }|]
+
+polygamma_out_tlt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+polygamma_out_tlt _out _n _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::polygamma_out(
+    *$(at::Tensor* _out)
+  , $(int64_t _n)
+  , *$(at::Tensor* _self)));
+  }|]
+
+polygamma_lt
+  :: Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+polygamma_lt _n _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::polygamma(
+    $(int64_t _n)
+  , *$(at::Tensor* _self)));
+  }|]
+
+erfinv_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+erfinv_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::erfinv(
+    *$(at::Tensor* _self)));
+  }|]
+
+erfinv_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+erfinv_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::erfinv_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+i0_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+i0_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::i0(
+    *$(at::Tensor* _self)));
+  }|]
+
+i0__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+i0__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::i0_(
+    *$(at::Tensor* _self)));
+  }|]
+
+i0_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+i0_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::i0_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+sign_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+sign_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sign(
+    *$(at::Tensor* _self)));
+  }|]
+
+sign_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sign_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sign_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+signbit_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+signbit_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::signbit(
+    *$(at::Tensor* _self)));
+  }|]
+
+signbit_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+signbit_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::signbit_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+dist_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+dist_tts _self _other _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dist(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)
+  , *$(at::Scalar* _p)));
+  }|]
+
+dist_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+dist_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::dist(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+atan2_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+atan2_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atan2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+atan2_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+atan2_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::atan2(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+arctan2_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+arctan2_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arctan2(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+arctan2_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+arctan2_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::arctan2_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+lerp_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+lerp_out_ttts _out _self _end _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lerp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _end)
+  , *$(at::Scalar* _weight)));
+  }|]
+
+lerp_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lerp_out_tttt _out _self _end _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lerp_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _end)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+lerp_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+lerp_tts _self _end _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lerp(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _end)
+  , *$(at::Scalar* _weight)));
+  }|]
+
+lerp_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+lerp_ttt _self _end _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::lerp(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _end)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+histc_out_ttlss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+histc_out_ttlss _out _self _bins _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::histc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+histc_out_ttls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+histc_out_ttls _out _self _bins _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::histc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(at::Scalar* _min)));
+  }|]
+
+histc_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+histc_out_ttl _out _self _bins =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::histc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _bins)));
+  }|]
+
+histc_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+histc_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::histc_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+histc_tlss
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+histc_tlss _self _bins _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::histc(
+    *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+histc_tls
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+histc_tls _self _bins _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::histc(
+    *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(at::Scalar* _min)));
+  }|]
+
+histc_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+histc_tl _self _bins =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::histc(
+    *$(at::Tensor* _self)
+  , $(int64_t _bins)));
+  }|]
+
+histc_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+histc_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::histc(
+    *$(at::Tensor* _self)));
+  }|]
+
+histogram_out_tttttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttttb _hist _bin_edges _self _bins _weight _density =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram_out(
+    *$(at::Tensor* _hist)
+  , *$(at::Tensor* _bin_edges)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _bins)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+histogram_out_ttttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_out_ttttt _hist _bin_edges _self _bins _weight =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram_out(
+    *$(at::Tensor* _hist)
+  , *$(at::Tensor* _bin_edges)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _bins)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+histogram_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttt _hist _bin_edges _self _bins =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram_out(
+    *$(at::Tensor* _hist)
+  , *$(at::Tensor* _bin_edges)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _bins)));
+  }|]
+
+histogram_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_tttb _self _bins _weight _density =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _bins)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+histogram_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_ttt _self _bins _weight =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _bins)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+histogram_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_tt _self _bins =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _bins)));
+  }|]
+
+histogram_out_tttlatb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttlatb _hist _bin_edges _self _bins _range _weight _density =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram_out(
+    *$(at::Tensor* _hist)
+  , *$(at::Tensor* _bin_edges)
+  , *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+histogram_out_tttlat
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttlat _hist _bin_edges _self _bins _range _weight =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram_out(
+    *$(at::Tensor* _hist)
+  , *$(at::Tensor* _bin_edges)
+  , *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+histogram_out_tttla
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttla _hist _bin_edges _self _bins _range =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram_out(
+    *$(at::Tensor* _hist)
+  , *$(at::Tensor* _bin_edges)
+  , *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(std::vector<double>* _range)));
+  }|]
+
+histogram_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_out_tttl _hist _bin_edges _self _bins =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram_out(
+    *$(at::Tensor* _hist)
+  , *$(at::Tensor* _bin_edges)
+  , *$(at::Tensor* _self)
+  , $(int64_t _bins)));
+  }|]
+
+histogram_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_out_ttt _hist _bin_edges _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram_out(
+    *$(at::Tensor* _hist)
+  , *$(at::Tensor* _bin_edges)
+  , *$(at::Tensor* _self)));
+  }|]
+
+histogram_tlatb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_tlatb _self _bins _range _weight _density =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram(
+    *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+histogram_tlat
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_tlat _self _bins _range _weight =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram(
+    *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+histogram_tla
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_tla _self _bins _range =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram(
+    *$(at::Tensor* _self)
+  , $(int64_t _bins)
+  , *$(std::vector<double>* _range)));
+  }|]
+
+histogram_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_tl _self _bins =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram(
+    *$(at::Tensor* _self)
+  , $(int64_t _bins)));
+  }|]
+
+histogram_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+histogram_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::histogram(
+    *$(at::Tensor* _self)));
+  }|]
+
+_histogramdd_bin_edges_tlatb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr TensorList)
+_histogramdd_bin_edges_tlatb _self _bins _range _weight _density =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_histogramdd_bin_edges(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+_histogramdd_bin_edges_tlat
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> IO (Ptr TensorList)
+_histogramdd_bin_edges_tlat _self _bins _range _weight =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_histogramdd_bin_edges(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+_histogramdd_bin_edges_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr TensorList)
+_histogramdd_bin_edges_tla _self _bins _range =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_histogramdd_bin_edges(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)));
+  }|]
+
+_histogramdd_bin_edges_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr TensorList)
+_histogramdd_bin_edges_tl _self _bins =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_histogramdd_bin_edges(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)));
+  }|]
+
+_histogramdd_from_bin_cts_tlatb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_cts_tlatb _self _bins _range _weight _density =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_cts(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+_histogramdd_from_bin_cts_tlat
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_cts_tlat _self _bins _range _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_cts(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+_histogramdd_from_bin_cts_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_cts_tla _self _bins _range =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_cts(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)));
+  }|]
+
+_histogramdd_from_bin_cts_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_cts_tl _self _bins =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_cts(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)));
+  }|]
+
+_histogramdd_from_bin_tensors_tltb
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_tensors_tltb _self _bins _weight _density =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_tensors(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Tensor>* _bins)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+_histogramdd_from_bin_tensors_tlt
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_tensors_tlt _self _bins _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_tensors(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Tensor>* _bins)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+_histogramdd_from_bin_tensors_tl
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> IO (Ptr Tensor)
+_histogramdd_from_bin_tensors_tl _self _bins =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_histogramdd_from_bin_tensors(
+    *$(at::Tensor* _self)
+  , *$(std::vector<at::Tensor>* _bins)));
+  }|]
+
+histogramdd_tlatb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,TensorList)))
+histogramdd_tlatb _self _bins _range _weight _density =
+  [C.throwBlock| std::tuple<at::Tensor,std::vector<at::Tensor>>* { return new std::tuple<at::Tensor,std::vector<at::Tensor>>(at::histogramdd(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+histogramdd_tlat
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,TensorList)))
+histogramdd_tlat _self _bins _range _weight =
+  [C.throwBlock| std::tuple<at::Tensor,std::vector<at::Tensor>>* { return new std::tuple<at::Tensor,std::vector<at::Tensor>>(at::histogramdd(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+histogramdd_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr (StdTuple '(Tensor,TensorList)))
+histogramdd_tla _self _bins _range =
+  [C.throwBlock| std::tuple<at::Tensor,std::vector<at::Tensor>>* { return new std::tuple<at::Tensor,std::vector<at::Tensor>>(at::histogramdd(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)
+  , *$(std::vector<double>* _range)));
+  }|]
+
+histogramdd_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,TensorList)))
+histogramdd_tl _self _bins =
+  [C.throwBlock| std::tuple<at::Tensor,std::vector<at::Tensor>>* { return new std::tuple<at::Tensor,std::vector<at::Tensor>>(at::histogramdd(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _bins)));
+  }|]
+
+fmod_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+fmod_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fmod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+fmod_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+fmod_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fmod(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+fmod_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fmod_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fmod_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+fmod_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fmod_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fmod(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+hypot_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hypot_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hypot_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+hypot_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hypot_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hypot(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+igamma_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+igamma_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::igamma_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+igamma_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+igamma_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::igamma(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+igammac_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+igammac_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::igammac_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+igammac_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+igammac_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::igammac(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+nextafter_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nextafter_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nextafter_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+nextafter_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nextafter_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nextafter(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+remainder_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+remainder_out_tts _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::remainder_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+remainder_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+remainder_ts _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::remainder(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+remainder_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+remainder_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::remainder_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+remainder_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+remainder_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::remainder(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+remainder_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+remainder_st _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::remainder(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+min_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+min_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::min(
+    *$(at::Tensor* _self)));
+  }|]
+
+fmin_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fmin_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fmin(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+fmin_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fmin_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fmin_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+max_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+max_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max(
+    *$(at::Tensor* _self)));
+  }|]
+
+fmax_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fmax_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fmax(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+fmax_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fmax_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fmax_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+maximum_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+maximum_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::maximum(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+maximum_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+maximum_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::maximum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+max_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+max_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+max_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+max_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+max_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+max_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+minimum_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+minimum_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::minimum(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+minimum_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+minimum_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::minimum_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+min_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+min_out_ttt _out _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::min_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+min_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+min_tt _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::min(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+quantile_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+quantile_ttlbs _self _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+quantile_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+quantile_ttlb _self _q _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+quantile_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+quantile_ttl _self _q _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)));
+  }|]
+
+quantile_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+quantile_tt _self _q =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)));
+  }|]
+
+quantile_out_tttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+quantile_out_tttlbs _out _self _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+quantile_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+quantile_out_tttlb _out _self _q _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+quantile_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+quantile_out_tttl _out _self _q _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)));
+  }|]
+
+quantile_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+quantile_out_ttt _out _self _q =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)));
+  }|]
+
+quantile_tdlbs
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+quantile_tdlbs _self _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
+    *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+quantile_tdlb
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+quantile_tdlb _self _q _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
+    *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+quantile_tdl
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+quantile_tdl _self _q _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
+    *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)));
+  }|]
+
+quantile_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+quantile_td _self _q =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
+    *$(at::Tensor* _self)
+  , $(double _q)));
+  }|]
+
+quantile_out_ttdlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+quantile_out_ttdlbs _out _self _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+quantile_out_ttdlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+quantile_out_ttdlb _out _self _q _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+quantile_out_ttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+quantile_out_ttdl _out _self _q _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)));
+  }|]
+
+quantile_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+quantile_out_ttd _out _self _q =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _q)));
+  }|]
+
+nanquantile_ttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+nanquantile_ttlbs _self _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+nanquantile_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+nanquantile_ttlb _self _q _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanquantile_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+nanquantile_ttl _self _q _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)));
+  }|]
+
+nanquantile_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nanquantile_tt _self _q =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)));
+  }|]
+
+nanquantile_out_tttlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+nanquantile_out_tttlbs _out _self _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+nanquantile_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+nanquantile_out_tttlb _out _self _q _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanquantile_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+nanquantile_out_tttl _out _self _q _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)
+  , $(int64_t _dim)));
+  }|]
+
+nanquantile_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nanquantile_out_ttt _out _self _q =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _q)));
+  }|]
+
+nanquantile_tdlbs
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+nanquantile_tdlbs _self _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
+    *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+nanquantile_tdlb
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+nanquantile_tdlb _self _q _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
+    *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanquantile_tdl
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+nanquantile_tdl _self _q _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
+    *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)));
+  }|]
+
+nanquantile_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+nanquantile_td _self _q =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
+    *$(at::Tensor* _self)
+  , $(double _q)));
+  }|]
+
+nanquantile_out_ttdlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+nanquantile_out_ttdlbs _out _self _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native8.hs b/src/Torch/Internal/Unmanaged/Native/Native8.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native8.hs
@@ -0,0 +1,3402 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native8 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+nanquantile_out_ttdlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+nanquantile_out_ttdlb _out _self _q _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+nanquantile_out_ttdl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+nanquantile_out_ttdl _out _self _q _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _q)
+  , $(int64_t _dim)));
+  }|]
+
+nanquantile_out_ttd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+nanquantile_out_ttd _out _self _q =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(double _q)));
+  }|]
+
+sort_out_tttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_tttlb _values _indices _self _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+sort_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_tttl _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+sort_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_ttt _values _indices _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)));
+  }|]
+
+sort_out_tttblb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_tttblb _values _indices _self _stable _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(bool _stable)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+sort_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_tttb _values _indices _self _stable =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(bool _stable)));
+  }|]
+
+sort_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_tlb _self _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+sort_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_tl _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+sort_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)));
+  }|]
+
+sort_tblb
+  :: Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_tblb _self _stable _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)
+  , $(bool _stable)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+-- sort_tbl
+--   :: Ptr Tensor
+--   -> CBool
+--   -> Int64
+--   -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+-- sort_tbl _self _stable _dim =
+--   [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+--     *$(at::Tensor* _self)
+--   , $(bool _stable)
+--   , $(int64_t _dim)));
+--   }|]
+
+sort_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_tb _self _stable =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)
+  , $(bool _stable)));
+  }|]
+
+sort_out_tttnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_tttnb _values _indices _self _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _descending)));
+  }|]
+
+sort_out_tttn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_tttn _values _indices _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+sort_out_tttbnb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_tttbnb _values _indices _self _stable _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(bool _stable)
+  , *$(at::Dimname* _dim)
+  , $(bool _descending)));
+  }|]
+
+sort_out_tttbn
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_out_tttbn _values _indices _self _stable _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(bool _stable)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+sort_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_tnb _self _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _descending)));
+  }|]
+
+sort_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_tn _self _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+sort_tbnb
+  :: Ptr Tensor
+  -> CBool
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_tbnb _self _stable _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)
+  , $(bool _stable)
+  , *$(at::Dimname* _dim)
+  , $(bool _descending)));
+  }|]
+
+sort_tbn
+  :: Ptr Tensor
+  -> CBool
+  -> Ptr Dimname
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+sort_tbn _self _stable _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
+    *$(at::Tensor* _self)
+  , $(bool _stable)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+msort_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+msort_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::msort_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+msort_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+msort_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::msort(
+    *$(at::Tensor* _self)));
+  }|]
+
+argsort_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+argsort_tlb _self _dim _descending =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+argsort_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+argsort_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+argsort_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+argsort_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
+    *$(at::Tensor* _self)));
+  }|]
+
+argsort_tblb
+  :: Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+argsort_tblb _self _stable _dim _descending =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
+    *$(at::Tensor* _self)
+  , $(bool _stable)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+argsort_tbl
+  :: Ptr Tensor
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+argsort_tbl _self _stable _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
+    *$(at::Tensor* _self)
+  , $(bool _stable)
+  , $(int64_t _dim)));
+  }|]
+
+argsort_tb
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+argsort_tb _self _stable =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
+    *$(at::Tensor* _self)
+  , $(bool _stable)));
+  }|]
+
+argsort_tnb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+argsort_tnb _self _dim _descending =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)
+  , $(bool _descending)));
+  }|]
+
+argsort_tn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+argsort_tn _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
+    *$(at::Tensor* _self)
+  , *$(at::Dimname* _dim)));
+  }|]
+
+topk_out_tttllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+topk_out_tttllbb _values _indices _self _k _dim _largest _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)
+  , $(bool _largest)
+  , $(bool _sorted)));
+  }|]
+
+topk_out_tttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+topk_out_tttllb _values _indices _self _k _dim _largest =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)
+  , $(bool _largest)));
+  }|]
+
+topk_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+topk_out_tttll _values _indices _self _k _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)));
+  }|]
+
+topk_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+topk_out_tttl _values _indices _self _k =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk_out(
+    *$(at::Tensor* _values)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , $(int64_t _k)));
+  }|]
+
+topk_tllbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+topk_tllbb _self _k _dim _largest _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)
+  , $(bool _largest)
+  , $(bool _sorted)));
+  }|]
+
+topk_tllb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+topk_tllb _self _k _dim _largest =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)
+  , $(bool _largest)));
+  }|]
+
+topk_tll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+topk_tll _self _k _dim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)
+  , $(int64_t _dim)));
+  }|]
+
+topk_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+topk_tl _self _k =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk(
+    *$(at::Tensor* _self)
+  , $(int64_t _k)));
+  }|]
+
+all_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+all_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all(
+    *$(at::Tensor* _self)));
+  }|]
+
+all_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+all_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::all_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+any_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+any_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any(
+    *$(at::Tensor* _self)));
+  }|]
+
+any_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+any_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::any_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+renorm_out_ttsls
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Int64
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+renorm_out_ttsls _out _self _p _dim _maxnorm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::renorm_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , $(int64_t _dim)
+  , *$(at::Scalar* _maxnorm)));
+  }|]
+
+renorm_tsls
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Int64
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+renorm_tsls _self _p _dim _maxnorm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::renorm(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _p)
+  , $(int64_t _dim)
+  , *$(at::Scalar* _maxnorm)));
+  }|]
+
+unfold_backward_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+unfold_backward_tllll _grad_in _input_sizes _dim _size _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unfold_backward(
+    *$(at::Tensor* _grad_in)
+  , *$(std::vector<int64_t>* _input_sizes)
+  , $(int64_t _dim)
+  , $(int64_t _size)
+  , $(int64_t _step)));
+  }|]
+
+equal_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+equal_tt _self _other =
+  [C.throwBlock| bool { return (at::equal(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+pow_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+pow_out_ttt _out _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pow_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _exponent)));
+  }|]
+
+pow_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+pow_tt _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pow(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _exponent)));
+  }|]
+
+pow_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+pow_out_tst _out _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pow_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _exponent)));
+  }|]
+
+pow_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+pow_st _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pow(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _exponent)));
+  }|]
+
+pow_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+pow_out_tts _out _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pow_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _exponent)));
+  }|]
+
+pow_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+pow_ts _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pow(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _exponent)));
+  }|]
+
+float_power_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+float_power_out_ttt _out _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::float_power_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _exponent)));
+  }|]
+
+float_power_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+float_power_tt _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::float_power(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _exponent)));
+  }|]
+
+float_power_out_tst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+float_power_out_tst _out _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::float_power_out(
+    *$(at::Tensor* _out)
+  , *$(at::Scalar* _self)
+  , *$(at::Tensor* _exponent)));
+  }|]
+
+float_power_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+float_power_st _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::float_power(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _exponent)));
+  }|]
+
+float_power_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+float_power_out_tts _out _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::float_power_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _exponent)));
+  }|]
+
+float_power_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+float_power_ts _self _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::float_power(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _exponent)));
+  }|]
+
+normal_functional_tddG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_functional_tddG _self _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_functional(
+    *$(at::Tensor* _self)
+  , $(double _mean)
+  , $(double _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_functional_tdd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+normal_functional_tdd _self _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_functional(
+    *$(at::Tensor* _self)
+  , $(double _mean)
+  , $(double _std)));
+  }|]
+
+normal_functional_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+normal_functional_td _self _mean =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_functional(
+    *$(at::Tensor* _self)
+  , $(double _mean)));
+  }|]
+
+normal_functional_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+normal_functional_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_functional(
+    *$(at::Tensor* _self)));
+  }|]
+
+normal_out_ttdG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_out_ttdG _out _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _mean)
+  , $(double _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+-- normal_out_ttd
+--   :: Ptr Tensor
+--   -> Ptr Tensor
+--   -> CDouble
+--   -> IO (Ptr Tensor)
+-- normal_out_ttd _out _mean _std =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+--     *$(at::Tensor* _out)
+--   , *$(at::Tensor* _mean)
+--   , $(double _std)));
+--   }|]
+
+-- normal_out_tt
+--   :: Ptr Tensor
+--   -> Ptr Tensor
+--   -> IO (Ptr Tensor)
+-- normal_out_tt _out _mean =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+--     *$(at::Tensor* _out)
+--   , *$(at::Tensor* _mean)));
+--   }|]
+
+normal_tdG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_tdG _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    *$(at::Tensor* _mean)
+  , $(double _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_td
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+normal_td _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    *$(at::Tensor* _mean)
+  , $(double _std)));
+  }|]
+
+normal_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+normal_t _mean =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    *$(at::Tensor* _mean)));
+  }|]
+
+normal_out_tdtG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_out_tdtG _out _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , $(double _mean)
+  , *$(at::Tensor* _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_out_tdt
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+normal_out_tdt _out _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , $(double _mean)
+  , *$(at::Tensor* _std)));
+  }|]
+
+normal_dtG
+  :: CDouble
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_dtG _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    $(double _mean)
+  , *$(at::Tensor* _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_dt
+  :: CDouble
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+normal_dt _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    $(double _mean)
+  , *$(at::Tensor* _std)));
+  }|]
+
+normal_out_tttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_out_tttG _out _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+normal_out_ttt _out _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _mean)
+  , *$(at::Tensor* _std)));
+  }|]
+
+normal_ttG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_ttG _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    *$(at::Tensor* _mean)
+  , *$(at::Tensor* _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+normal_tt _mean _std =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    *$(at::Tensor* _mean)
+  , *$(at::Tensor* _std)));
+  }|]
+
+normal_ddlGo
+  :: CDouble
+  -> CDouble
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+normal_ddlGo _mean _std _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    $(double _mean)
+  , $(double _std)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+normal_ddlG
+  :: CDouble
+  -> CDouble
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_ddlG _mean _std _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    $(double _mean)
+  , $(double _std)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_ddl
+  :: CDouble
+  -> CDouble
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+normal_ddl _mean _std _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
+    $(double _mean)
+  , $(double _std)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+normal_out_tddlG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_out_tddlG _out _mean _std _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , $(double _mean)
+  , $(double _std)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_out_tddl
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+normal_out_tddl _out _mean _std _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
+    *$(at::Tensor* _out)
+  , $(double _mean)
+  , $(double _std)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+alias_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+alias_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::alias(
+    *$(at::Tensor* _self)));
+  }|]
+
+_amp_foreach_non_finite_check_and_unscale__ltt
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+_amp_foreach_non_finite_check_and_unscale__ltt _self _found_inf _inv_scale =
+  [C.throwBlock| void {  (at::_amp_foreach_non_finite_check_and_unscale_(
+    *$(std::vector<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 _self _growth_tracker _found_inf _scale_growth_factor _scale_backoff_factor _growth_interval =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_amp_update_scale_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _growth_tracker)
+  , *$(at::Tensor* _found_inf)
+  , $(double _scale_growth_factor)
+  , $(double _scale_backoff_factor)
+  , $(int64_t _growth_interval)));
+  }|]
+
+_foreach_add_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_add_ls _self _scalar =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_add(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_add__ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_add__ls _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_add_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_sub_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_sub_ls _self _scalar =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sub(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_sub__ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_sub__ls _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_sub_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_mul_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_mul_ls _self _scalar =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_mul(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_mul__ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_mul__ls _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_mul_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_div_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_div_ls _self _scalar =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_div(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_div__ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_div__ls _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_div_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_clamp_min_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_clamp_min_ls _self _scalar =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_clamp_min(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_clamp_min__ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_clamp_min__ls _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_clamp_min_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_clamp_max_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_clamp_max_ls _self _scalar =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_clamp_max(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_clamp_max__ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_clamp_max__ls _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_clamp_max_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_maximum_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_maximum_ls _self _scalar =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_maximum(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_maximum__ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_maximum__ls _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_maximum_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_minimum_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_minimum_ls _self _scalar =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_minimum(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_minimum__ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_minimum__ls _self _scalar =
+  [C.throwBlock| void {  (at::_foreach_minimum_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _scalar)));
+  }|]
+
+_foreach_add_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_add_lls _self _other _alpha =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_add(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_foreach_add_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_add_ll _self _other =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_add(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_add__lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_add__lls _self _other _alpha =
+  [C.throwBlock| void {  (at::_foreach_add_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_foreach_add__ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_add__ll _self _other =
+  [C.throwBlock| void {  (at::_foreach_add_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_sub_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_sub_lls _self _other _alpha =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sub(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_foreach_sub_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_sub_ll _self _other =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sub(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_sub__lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_sub__lls _self _other _alpha =
+  [C.throwBlock| void {  (at::_foreach_sub_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+_foreach_sub__ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_sub__ll _self _other =
+  [C.throwBlock| void {  (at::_foreach_sub_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_mul_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_mul_ll _self _other =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_mul(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_mul__ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_mul__ll _self _other =
+  [C.throwBlock| void {  (at::_foreach_mul_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_div_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_div_ll _self _other =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_div(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_div__ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_div__ll _self _other =
+  [C.throwBlock| void {  (at::_foreach_div_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_clamp_min_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_clamp_min_ll _self _other =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_clamp_min(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_clamp_min__ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_clamp_min__ll _self _other =
+  [C.throwBlock| void {  (at::_foreach_clamp_min_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_clamp_max_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_clamp_max_ll _self _other =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_clamp_max(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_clamp_max__ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_clamp_max__ll _self _other =
+  [C.throwBlock| void {  (at::_foreach_clamp_max_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_maximum_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_maximum_ll _self _other =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_maximum(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_maximum__ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_maximum__ll _self _other =
+  [C.throwBlock| void {  (at::_foreach_maximum_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_minimum_ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_minimum_ll _self _other =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_minimum(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_minimum__ll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_minimum__ll _self _other =
+  [C.throwBlock| void {  (at::_foreach_minimum_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _other)));
+  }|]
+
+_foreach_add_lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_add_lA _self _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_add(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_add__lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_add__lA _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_add_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_sub_lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_sub_lA _self _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sub(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_sub__lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_sub__lA _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_sub_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_div_lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_div_lA _self _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_div(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_div__lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_div__lA _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_div_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_mul_lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_mul_lA _self _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_mul(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_mul__lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_mul__lA _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_mul_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_clamp_min_lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_clamp_min_lA _self _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_clamp_min(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_clamp_min__lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_clamp_min__lA _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_clamp_min_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_clamp_max_lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_clamp_max_lA _self _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_clamp_max(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_clamp_max__lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_clamp_max__lA _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_clamp_max_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_maximum_lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_maximum_lA _self _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_maximum(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_maximum__lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_maximum__lA _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_maximum_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_minimum_lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_minimum_lA _self _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_minimum(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_minimum__lA
+  :: Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_minimum__lA _self _scalars =
+  [C.throwBlock| void {  (at::_foreach_minimum_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_exp_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_exp_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_exp(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_zero__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_zero__l _self =
+  [C.throwBlock| void {  (at::_foreach_zero_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_exp__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_exp__l _self =
+  [C.throwBlock| void {  (at::_foreach_exp_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sqrt_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_sqrt_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sqrt(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sqrt__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_sqrt__l _self =
+  [C.throwBlock| void {  (at::_foreach_sqrt_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_abs_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_abs_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_abs(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_abs__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_abs__l _self =
+  [C.throwBlock| void {  (at::_foreach_abs_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_acos_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_acos_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_acos(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_acos__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_acos__l _self =
+  [C.throwBlock| void {  (at::_foreach_acos_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_asin_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_asin_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_asin(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_asin__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_asin__l _self =
+  [C.throwBlock| void {  (at::_foreach_asin_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_atan_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_atan_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_atan(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_atan__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_atan__l _self =
+  [C.throwBlock| void {  (at::_foreach_atan_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_ceil_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_ceil_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_ceil(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_ceil__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_ceil__l _self =
+  [C.throwBlock| void {  (at::_foreach_ceil_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_cos_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_cos_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_cos(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_cos__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_cos__l _self =
+  [C.throwBlock| void {  (at::_foreach_cos_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_cosh_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_cosh_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_cosh(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_cosh__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_cosh__l _self =
+  [C.throwBlock| void {  (at::_foreach_cosh_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_erf_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_erf_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_erf(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_erf__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_erf__l _self =
+  [C.throwBlock| void {  (at::_foreach_erf_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_erfc_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_erfc_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_erfc(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_erfc__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_erfc__l _self =
+  [C.throwBlock| void {  (at::_foreach_erfc_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_expm1_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_expm1_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_expm1(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_expm1__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_expm1__l _self =
+  [C.throwBlock| void {  (at::_foreach_expm1_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_floor_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_floor_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_floor(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_floor__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_floor__l _self =
+  [C.throwBlock| void {  (at::_foreach_floor_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_log_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_log(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_log__l _self =
+  [C.throwBlock| void {  (at::_foreach_log_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log10_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_log10_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_log10(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log10__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_log10__l _self =
+  [C.throwBlock| void {  (at::_foreach_log10_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log1p_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_log1p_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_log1p(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log1p__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_log1p__l _self =
+  [C.throwBlock| void {  (at::_foreach_log1p_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log2_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_log2_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_log2(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_log2__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_log2__l _self =
+  [C.throwBlock| void {  (at::_foreach_log2_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_neg_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_neg_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_neg(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_neg__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_neg__l _self =
+  [C.throwBlock| void {  (at::_foreach_neg_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_tan_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_tan_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_tan(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_tan__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_tan__l _self =
+  [C.throwBlock| void {  (at::_foreach_tan_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_tanh_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_tanh_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_tanh(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_tanh__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_tanh__l _self =
+  [C.throwBlock| void {  (at::_foreach_tanh_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sin_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_sin_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sin(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sin__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_sin__l _self =
+  [C.throwBlock| void {  (at::_foreach_sin_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sinh_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_sinh_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sinh(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sinh__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_sinh__l _self =
+  [C.throwBlock| void {  (at::_foreach_sinh_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_round_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_round_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_round(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_round__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_round__l _self =
+  [C.throwBlock| void {  (at::_foreach_round_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_lgamma_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_lgamma_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_lgamma(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_lgamma__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_lgamma__l _self =
+  [C.throwBlock| void {  (at::_foreach_lgamma_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_frac_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_frac_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_frac(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_frac__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_frac__l _self =
+  [C.throwBlock| void {  (at::_foreach_frac_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_reciprocal_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_reciprocal_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_reciprocal(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_reciprocal__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_reciprocal__l _self =
+  [C.throwBlock| void {  (at::_foreach_reciprocal_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sigmoid_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_sigmoid_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sigmoid(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_sigmoid__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_sigmoid__l _self =
+  [C.throwBlock| void {  (at::_foreach_sigmoid_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_trunc_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_trunc_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_trunc(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_trunc__l
+  :: Ptr TensorList
+  -> IO (())
+_foreach_trunc__l _self =
+  [C.throwBlock| void {  (at::_foreach_trunc_(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_addcdiv__llls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_addcdiv__llls _self _tensor1 _tensor2 _value =
+  [C.throwBlock| void {  (at::_foreach_addcdiv_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+_foreach_addcdiv__lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_addcdiv__lll _self _tensor1 _tensor2 =
+  [C.throwBlock| void {  (at::_foreach_addcdiv_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)));
+  }|]
+
+_foreach_addcmul__llls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_addcmul__llls _self _tensor1 _tensor2 _value =
+  [C.throwBlock| void {  (at::_foreach_addcmul_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+_foreach_addcmul__lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_addcmul__lll _self _tensor1 _tensor2 =
+  [C.throwBlock| void {  (at::_foreach_addcmul_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)));
+  }|]
+
+_foreach_addcdiv__lllA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_addcdiv__lllA _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| void {  (at::_foreach_addcdiv_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_addcdiv__lllt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> IO (())
+_foreach_addcdiv__lllt _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| void {  (at::_foreach_addcdiv_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Tensor* _scalars)));
+  }|]
+
+_foreach_addcmul__lllA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (())
+_foreach_addcmul__lllA _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| void {  (at::_foreach_addcmul_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_addcmul__lllt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> IO (())
+_foreach_addcmul__lllt _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| void {  (at::_foreach_addcmul_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Tensor* _scalars)));
+  }|]
+
+_foreach_addcdiv_llls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_addcdiv_llls _self _tensor1 _tensor2 _value =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcdiv(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+_foreach_addcdiv_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_addcdiv_lll _self _tensor1 _tensor2 =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcdiv(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)));
+  }|]
+
+_foreach_addcmul_llls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_addcmul_llls _self _tensor1 _tensor2 _value =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcmul(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+_foreach_addcmul_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_addcmul_lll _self _tensor1 _tensor2 =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcmul(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)));
+  }|]
+
+_foreach_addcdiv_lllA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_addcdiv_lllA _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcdiv(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_addcdiv_lllt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> IO (Ptr TensorList)
+_foreach_addcdiv_lllt _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcdiv(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Tensor* _scalars)));
+  }|]
+
+_foreach_addcmul_lllA
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr (StdVector Scalar)
+  -> IO (Ptr TensorList)
+_foreach_addcmul_lllA _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcmul(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(std::vector<at::Scalar>* _scalars)));
+  }|]
+
+_foreach_addcmul_lllt
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> IO (Ptr TensorList)
+_foreach_addcmul_lllt _self _tensor1 _tensor2 _scalars =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcmul(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensor1)
+  , *$(std::vector<at::Tensor>* _tensor2)
+  , *$(at::Tensor* _scalars)));
+  }|]
+
+_foreach_norm_ls
+  :: Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_norm_ls _self _ord =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_norm(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(at::Scalar* _ord)));
+  }|]
+
+_foreach_norm_l
+  :: Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_norm_l _self =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_norm(
+    *$(std::vector<at::Tensor>* _self)));
+  }|]
+
+_foreach_lerp_lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (Ptr TensorList)
+_foreach_lerp_lll _self _tensors1 _weights =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_lerp(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensors1)
+  , *$(std::vector<at::Tensor>* _weights)));
+  }|]
+
+_foreach_lerp__lll
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr TensorList
+  -> IO (())
+_foreach_lerp__lll _self _tensors1 _weights =
+  [C.throwBlock| void {  (at::_foreach_lerp_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensors1)
+  , *$(std::vector<at::Tensor>* _weights)));
+  }|]
+
+_foreach_lerp_lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (Ptr TensorList)
+_foreach_lerp_lls _self _tensors1 _weight =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_lerp(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensors1)
+  , *$(at::Scalar* _weight)));
+  }|]
+
+_foreach_lerp__lls
+  :: Ptr TensorList
+  -> Ptr TensorList
+  -> Ptr Scalar
+  -> IO (())
+_foreach_lerp__lls _self _tensors1 _weight =
+  [C.throwBlock| void {  (at::_foreach_lerp_(
+    *$(std::vector<at::Tensor>* _self)
+  , *$(std::vector<at::Tensor>* _tensors1)
+  , *$(at::Scalar* _weight)));
+  }|]
+
+bucketize_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+bucketize_ttbb _self _boundaries _out_int32 _right =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _boundaries)
+  , $(bool _out_int32)
+  , $(bool _right)));
+  }|]
+
+bucketize_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+bucketize_ttb _self _boundaries _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _boundaries)
+  , $(bool _out_int32)));
+  }|]
+
+bucketize_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bucketize_tt _self _boundaries =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _boundaries)));
+  }|]
+
+bucketize_out_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+bucketize_out_tttbb _out _self _boundaries _out_int32 _right =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _boundaries)
+  , $(bool _out_int32)
+  , $(bool _right)));
+  }|]
+
+bucketize_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+bucketize_out_tttb _out _self _boundaries _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _boundaries)
+  , $(bool _out_int32)));
+  }|]
+
+bucketize_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bucketize_out_ttt _out _self _boundaries =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _boundaries)));
+  }|]
+
+bucketize_stbb
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+bucketize_stbb _self _boundaries _out_int32 _right =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _boundaries)
+  , $(bool _out_int32)
+  , $(bool _right)));
+  }|]
+
+bucketize_stb
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+bucketize_stb _self _boundaries _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _boundaries)
+  , $(bool _out_int32)));
+  }|]
+
+bucketize_st
+  :: Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+bucketize_st _self _boundaries =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::bucketize(
+    *$(at::Scalar* _self)
+  , *$(at::Tensor* _boundaries)));
+  }|]
+
+searchsorted_ttbbst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+searchsorted_ttbbst _sorted_sequence _self _out_int32 _right _side _sorter =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)
+  , $(bool _out_int32)
+  , $(bool _right)
+  , *$(std::string* _side)
+  , *$(at::Tensor* _sorter)));
+  }|]
+
+searchsorted_ttbbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+searchsorted_ttbbs _sorted_sequence _self _out_int32 _right _side =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)
+  , $(bool _out_int32)
+  , $(bool _right)
+  , *$(std::string* _side)));
+  }|]
+
+searchsorted_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+searchsorted_ttbb _sorted_sequence _self _out_int32 _right =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)
+  , $(bool _out_int32)
+  , $(bool _right)));
+  }|]
+
+searchsorted_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+searchsorted_ttb _sorted_sequence _self _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)
+  , $(bool _out_int32)));
+  }|]
+
+searchsorted_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+searchsorted_tt _sorted_sequence _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)));
+  }|]
+
+searchsorted_out_tttbbst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+searchsorted_out_tttbbst _out _sorted_sequence _self _out_int32 _right _side _sorter =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)
+  , $(bool _out_int32)
+  , $(bool _right)
+  , *$(std::string* _side)
+  , *$(at::Tensor* _sorter)));
+  }|]
+
+searchsorted_out_tttbbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+searchsorted_out_tttbbs _out _sorted_sequence _self _out_int32 _right _side =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)
+  , $(bool _out_int32)
+  , $(bool _right)
+  , *$(std::string* _side)));
+  }|]
+
+searchsorted_out_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+searchsorted_out_tttbb _out _sorted_sequence _self _out_int32 _right =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)
+  , $(bool _out_int32)
+  , $(bool _right)));
+  }|]
+
+searchsorted_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+searchsorted_out_tttb _out _sorted_sequence _self _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)
+  , $(bool _out_int32)));
+  }|]
+
+searchsorted_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+searchsorted_out_ttt _out _sorted_sequence _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _sorted_sequence)
+  , *$(at::Tensor* _self)));
+  }|]
+
+searchsorted_tsbbst
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+searchsorted_tsbbst _sorted_sequence _self _out_int32 _right _side _sorter =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)
+  , $(bool _out_int32)
+  , $(bool _right)
+  , *$(std::string* _side)
+  , *$(at::Tensor* _sorter)));
+  }|]
+
+searchsorted_tsbbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+searchsorted_tsbbs _sorted_sequence _self _out_int32 _right _side =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)
+  , $(bool _out_int32)
+  , $(bool _right)
+  , *$(std::string* _side)));
+  }|]
+
+searchsorted_tsbb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+searchsorted_tsbb _sorted_sequence _self _out_int32 _right =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)
+  , $(bool _out_int32)
+  , $(bool _right)));
+  }|]
+
+searchsorted_tsb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+searchsorted_tsb _sorted_sequence _self _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)
+  , $(bool _out_int32)));
+  }|]
+
+searchsorted_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+searchsorted_ts _sorted_sequence _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
+    *$(at::Tensor* _sorted_sequence)
+  , *$(at::Scalar* _self)));
+  }|]
+
+_convert_indices_from_coo_to_csr_tlb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_convert_indices_from_coo_to_csr_tlb _self _size _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_coo_to_csr(
+    *$(at::Tensor* _self)
+  , $(int64_t _size)
+  , $(bool _out_int32)));
+  }|]
+
+_convert_indices_from_coo_to_csr_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_convert_indices_from_coo_to_csr_tl _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_coo_to_csr(
+    *$(at::Tensor* _self)
+  , $(int64_t _size)));
+  }|]
+
+_convert_indices_from_coo_to_csr_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+_convert_indices_from_coo_to_csr_out_ttlb _out _self _size _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_coo_to_csr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _size)
+  , $(bool _out_int32)));
+  }|]
+
+_convert_indices_from_coo_to_csr_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_convert_indices_from_coo_to_csr_out_ttl _out _self _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_coo_to_csr_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _size)));
+  }|]
+
+_convert_indices_from_csr_to_coo_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_convert_indices_from_csr_to_coo_ttbb _crow_indices _col_indices _out_int32 _transpose =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_csr_to_coo(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , $(bool _out_int32)
+  , $(bool _transpose)));
+  }|]
+
+_convert_indices_from_csr_to_coo_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_convert_indices_from_csr_to_coo_ttb _crow_indices _col_indices _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_csr_to_coo(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , $(bool _out_int32)));
+  }|]
+
+_convert_indices_from_csr_to_coo_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_convert_indices_from_csr_to_coo_tt _crow_indices _col_indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_csr_to_coo(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)));
+  }|]
+
+_convert_indices_from_csr_to_coo_out_tttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+_convert_indices_from_csr_to_coo_out_tttbb _out _crow_indices _col_indices _out_int32 _transpose =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_csr_to_coo_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , $(bool _out_int32)
+  , $(bool _transpose)));
+  }|]
+
+_convert_indices_from_csr_to_coo_out_tttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+_convert_indices_from_csr_to_coo_out_tttb _out _crow_indices _col_indices _out_int32 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_csr_to_coo_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , $(bool _out_int32)));
+  }|]
+
+_convert_indices_from_csr_to_coo_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_convert_indices_from_csr_to_coo_out_ttt _out _crow_indices _col_indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_convert_indices_from_csr_to_coo_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)));
+  }|]
+
+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)));
+  }|]
+
+l1_loss_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+l1_loss_ttl _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::l1_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+l1_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+l1_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::l1_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+multi_margin_loss_out_tttsstl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+multi_margin_loss_out_tttsstl _out _self _target _p _margin _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+multi_margin_loss_out_tttsst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multi_margin_loss_out_tttsst _out _self _target _p _margin _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+multi_margin_loss_out_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+multi_margin_loss_out_tttss _out _self _target _p _margin =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)));
+  }|]
+
+multi_margin_loss_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+multi_margin_loss_out_ttts _out _self _target _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)));
+  }|]
+
+multi_margin_loss_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multi_margin_loss_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+multi_margin_loss_ttsstl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+multi_margin_loss_ttsstl _self _target _p _margin _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+multi_margin_loss_ttsst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multi_margin_loss_ttsst _self _target _p _margin _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+multi_margin_loss_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+multi_margin_loss_ttss _self _target _p _margin =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)));
+  }|]
+
+multi_margin_loss_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+multi_margin_loss_tts _self _target _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)));
+  }|]
+
+multi_margin_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multi_margin_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+multi_margin_loss_backward_out_ttttsstl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+multi_margin_loss_backward_out_ttttsstl _grad_input _grad_output _self _target _p _margin _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+multi_margin_loss_backward_out_ttttsst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multi_margin_loss_backward_out_ttttsst _grad_input _grad_output _self _target _p _margin _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+multi_margin_loss_backward_out_ttttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+multi_margin_loss_backward_out_ttttss _grad_input _grad_output _self _target _p _margin =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)));
+  }|]
+
+multi_margin_loss_backward_tttsstl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+multi_margin_loss_backward_tttsstl _grad_output _self _target _p _margin _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+multi_margin_loss_backward_tttsst
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multi_margin_loss_backward_tttsst _grad_output _self _target _p _margin _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+multi_margin_loss_backward_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+multi_margin_loss_backward_tttss _grad_output _self _target _p _margin =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multi_margin_loss_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Scalar* _p)
+  , *$(at::Scalar* _margin)));
+  }|]
+
+multilabel_margin_loss_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+multilabel_margin_loss_out_tttl _out _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multilabel_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+multilabel_margin_loss_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multilabel_margin_loss_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multilabel_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+multilabel_margin_loss_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+multilabel_margin_loss_ttl _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multilabel_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+multilabel_margin_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multilabel_margin_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multilabel_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+multilabel_margin_loss_forward_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+multilabel_margin_loss_forward_out_ttttl _output _is_target _self _target _reduction =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::multilabel_margin_loss_forward_out(
+    *$(at::Tensor* _output)
+  , *$(at::Tensor* _is_target)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+multilabel_margin_loss_forward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+multilabel_margin_loss_forward_ttl _self _target _reduction =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::multilabel_margin_loss_forward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+multilabel_margin_loss_backward_out_ttttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multilabel_margin_loss_backward_out_ttttlt _grad_input _grad_output _self _target _reduction _is_target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multilabel_margin_loss_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , *$(at::Tensor* _is_target)));
+  }|]
+
+multilabel_margin_loss_backward_tttlt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+multilabel_margin_loss_backward_tttlt _grad_output _self _target _reduction _is_target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::multilabel_margin_loss_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , *$(at::Tensor* _is_target)));
+  }|]
+
+nll_loss_out_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss_out_ttttll _out _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss_out_ttttl _out _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+nll_loss_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss_out_tttt _out _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+nll_loss_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+nll_loss_nd_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss_nd_tttll _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_nd(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss_nd_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss_nd_tttl _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_nd(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+nll_loss_nd_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss_nd_ttt _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_nd(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+nll_loss_nd_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss_nd_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_nd(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Native/Native9.hs b/src/Torch/Internal/Unmanaged/Native/Native9.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Native/Native9.hs
@@ -0,0 +1,4036 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Native.Native9 where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+
+nll_loss_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss_tttll _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss_tttl _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+nll_loss_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss_ttt _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+nll_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+nll_loss_forward_out_tttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nll_loss_forward_out_tttttll _output _total_weight _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nll_loss_forward_out(
+    *$(at::Tensor* _output)
+  , *$(at::Tensor* _total_weight)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss_forward_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nll_loss_forward_tttll _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nll_loss_forward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss_backward_out_tttttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss_backward_out_tttttllt _grad_input _grad_output _self _target _weight _reduction _ignore_index _total_weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)
+  , *$(at::Tensor* _total_weight)));
+  }|]
+
+nll_loss_backward_ttttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss_backward_ttttllt _grad_output _self _target _weight _reduction _ignore_index _total_weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)
+  , *$(at::Tensor* _total_weight)));
+  }|]
+
+nll_loss2d_out_ttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss2d_out_ttttll _out _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss2d_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss2d_out_ttttl _out _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+nll_loss2d_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss2d_out_tttt _out _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+nll_loss2d_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss2d_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+nll_loss2d_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss2d_tttll _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss2d_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+nll_loss2d_tttl _self _target _weight _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)));
+  }|]
+
+nll_loss2d_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss2d_ttt _self _target _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+nll_loss2d_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss2d_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+nll_loss2d_forward_out_tttttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nll_loss2d_forward_out_tttttll _output _total_weight _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nll_loss2d_forward_out(
+    *$(at::Tensor* _output)
+  , *$(at::Tensor* _total_weight)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss2d_forward_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+nll_loss2d_forward_tttll _self _target _weight _reduction _ignore_index =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::nll_loss2d_forward(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)));
+  }|]
+
+nll_loss2d_backward_out_tttttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss2d_backward_out_tttttllt _grad_input _grad_output _self _target _weight _reduction _ignore_index _total_weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)
+  , *$(at::Tensor* _total_weight)));
+  }|]
+
+nll_loss2d_backward_ttttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+nll_loss2d_backward_ttttllt _grad_output _self _target _weight _reduction _ignore_index _total_weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , *$(at::Tensor* _weight)
+  , $(int64_t _reduction)
+  , $(int64_t _ignore_index)
+  , *$(at::Tensor* _total_weight)));
+  }|]
+
+smooth_l1_loss_out_tttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+smooth_l1_loss_out_tttld _out _self _target _reduction _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smooth_l1_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(double _beta)));
+  }|]
+
+smooth_l1_loss_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+smooth_l1_loss_out_tttl _out _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smooth_l1_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+smooth_l1_loss_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+smooth_l1_loss_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smooth_l1_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+smooth_l1_loss_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+smooth_l1_loss_ttld _self _target _reduction _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smooth_l1_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(double _beta)));
+  }|]
+
+smooth_l1_loss_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+smooth_l1_loss_ttl _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smooth_l1_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+smooth_l1_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+smooth_l1_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smooth_l1_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+smooth_l1_loss_backward_out_ttttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+smooth_l1_loss_backward_out_ttttld _grad_input _grad_output _self _target _reduction _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smooth_l1_loss_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(double _beta)));
+  }|]
+
+smooth_l1_loss_backward_tttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+smooth_l1_loss_backward_tttld _grad_output _self _target _reduction _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::smooth_l1_loss_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(double _beta)));
+  }|]
+
+huber_loss_out_tttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+huber_loss_out_tttld _out _self _target _reduction _delta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::huber_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(double _delta)));
+  }|]
+
+huber_loss_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+huber_loss_out_tttl _out _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::huber_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+huber_loss_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+huber_loss_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::huber_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+huber_loss_ttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+huber_loss_ttld _self _target _reduction _delta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::huber_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(double _delta)));
+  }|]
+
+huber_loss_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+huber_loss_ttl _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::huber_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+huber_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+huber_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::huber_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+huber_loss_backward_out_ttttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+huber_loss_backward_out_ttttld _grad_input _grad_output _self _target _reduction _delta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::huber_loss_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(double _delta)));
+  }|]
+
+huber_loss_backward_tttld
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+huber_loss_backward_tttld _grad_output _self _target _reduction _delta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::huber_loss_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)
+  , $(double _delta)));
+  }|]
+
+soft_margin_loss_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+soft_margin_loss_out_tttl _out _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::soft_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+soft_margin_loss_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+soft_margin_loss_out_ttt _out _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::soft_margin_loss_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+soft_margin_loss_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+soft_margin_loss_ttl _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::soft_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+soft_margin_loss_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+soft_margin_loss_tt _self _target =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::soft_margin_loss(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)));
+  }|]
+
+soft_margin_loss_backward_out_ttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+soft_margin_loss_backward_out_ttttl _grad_input _grad_output _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::soft_margin_loss_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+soft_margin_loss_backward_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+soft_margin_loss_backward_tttl _grad_output _self _target _reduction =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::soft_margin_loss_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _target)
+  , $(int64_t _reduction)));
+  }|]
+
+elu_out_ttsss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu_out_ttsss _out _self _alpha _scale _input_scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Scalar* _scale)
+  , *$(at::Scalar* _input_scale)));
+  }|]
+
+elu_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu_out_ttss _out _self _alpha _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Scalar* _scale)));
+  }|]
+
+elu_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu_out_tts _out _self _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+elu_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+elu_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+elu_tsss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu_tsss _self _alpha _scale _input_scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Scalar* _scale)
+  , *$(at::Scalar* _input_scale)));
+  }|]
+
+elu_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu_tss _self _alpha _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Scalar* _scale)));
+  }|]
+
+elu_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu_ts _self _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+elu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+elu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu(
+    *$(at::Tensor* _self)));
+  }|]
+
+elu_backward_out_ttsssbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+elu_backward_out_ttsssbt _grad_input _grad_output _alpha _scale _input_scale _is_result _self_or_result =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Scalar* _scale)
+  , *$(at::Scalar* _input_scale)
+  , $(bool _is_result)
+  , *$(at::Tensor* _self_or_result)));
+  }|]
+
+elu_backward_tsssbt
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+elu_backward_tsssbt _grad_output _alpha _scale _input_scale _is_result _self_or_result =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Scalar* _scale)
+  , *$(at::Scalar* _input_scale)
+  , $(bool _is_result)
+  , *$(at::Tensor* _self_or_result)));
+  }|]
+
+elu__tsss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu__tsss _self _alpha _scale _input_scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Scalar* _scale)
+  , *$(at::Scalar* _input_scale)));
+  }|]
+
+elu__tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu__tss _self _alpha _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)
+  , *$(at::Scalar* _scale)));
+  }|]
+
+elu__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+elu__ts _self _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+elu__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+elu__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::elu_(
+    *$(at::Tensor* _self)));
+  }|]
+
+glu_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+glu_out_ttl _out _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+glu_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+glu_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+glu_tl
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+glu_tl _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu(
+    *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+glu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+glu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu(
+    *$(at::Tensor* _self)));
+  }|]
+
+glu_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+glu_backward_out_tttl _grad_input _grad_output _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+glu_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+glu_backward_ttl _grad_output _self _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , $(int64_t _dim)));
+  }|]
+
+glu_jvp_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+glu_jvp_tttl _glu _x _dx _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_jvp(
+    *$(at::Tensor* _glu)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _dx)
+  , $(int64_t _dim)));
+  }|]
+
+glu_backward_jvp_tttttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+glu_backward_jvp_tttttl _grad_x _grad_glu _x _dgrad_glu _dx _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_backward_jvp(
+    *$(at::Tensor* _grad_x)
+  , *$(at::Tensor* _grad_glu)
+  , *$(at::Tensor* _x)
+  , *$(at::Tensor* _dgrad_glu)
+  , *$(at::Tensor* _dx)
+  , $(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_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hardsigmoid_backward_out_ttt _grad_input _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardsigmoid_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(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
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardtanh_out_ttss _out _self _min_val _max_val =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min_val)
+  , *$(at::Scalar* _max_val)));
+  }|]
+
+hardtanh_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardtanh_out_tts _out _self _min_val =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min_val)));
+  }|]
+
+hardtanh_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hardtanh_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+hardtanh_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardtanh_tss _self _min_val _max_val =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min_val)
+  , *$(at::Scalar* _max_val)));
+  }|]
+
+hardtanh_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardtanh_ts _self _min_val =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min_val)));
+  }|]
+
+hardtanh_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+hardtanh_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh(
+    *$(at::Tensor* _self)));
+  }|]
+
+hardtanh_backward_out_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardtanh_backward_out_tttss _grad_input _grad_output _self _min_val _max_val =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min_val)
+  , *$(at::Scalar* _max_val)));
+  }|]
+
+hardtanh_backward_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardtanh_backward_ttss _grad_output _self _min_val _max_val =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _min_val)
+  , *$(at::Scalar* _max_val)));
+  }|]
+
+hardtanh__tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardtanh__tss _self _min_val _max_val =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min_val)
+  , *$(at::Scalar* _max_val)));
+  }|]
+
+hardtanh__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+hardtanh__ts _self _min_val =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _min_val)));
+  }|]
+
+hardtanh__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+hardtanh__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardtanh_(
+    *$(at::Tensor* _self)));
+  }|]
+
+hardswish_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hardswish_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardswish_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+hardswish_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+hardswish_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardswish(
+    *$(at::Tensor* _self)));
+  }|]
+
+hardswish__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+hardswish__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardswish_(
+    *$(at::Tensor* _self)));
+  }|]
+
+hardswish_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+hardswish_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardswish_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+leaky_relu_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+leaky_relu_out_tts _out _self _negative_slope =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::leaky_relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _negative_slope)));
+  }|]
+
+leaky_relu_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+leaky_relu_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::leaky_relu_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+leaky_relu_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+leaky_relu_ts _self _negative_slope =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::leaky_relu(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _negative_slope)));
+  }|]
+
+leaky_relu_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+leaky_relu_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::leaky_relu(
+    *$(at::Tensor* _self)));
+  }|]
+
+leaky_relu_backward_out_tttsb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+leaky_relu_backward_out_tttsb _grad_input _grad_output _self _negative_slope _self_is_result =
+  [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)
+  , $(bool _self_is_result)));
+  }|]
+
+leaky_relu_backward_ttsb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+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)
+  , $(bool _self_is_result)));
+  }|]
+
+leaky_relu__ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+leaky_relu__ts _self _negative_slope =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::leaky_relu_(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _negative_slope)));
+  }|]
+
+leaky_relu__t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+leaky_relu__t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::leaky_relu_(
+    *$(at::Tensor* _self)));
+  }|]
+
+log_sigmoid_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+log_sigmoid_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_sigmoid_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+log_sigmoid_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+log_sigmoid_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_sigmoid(
+    *$(at::Tensor* _self)));
+  }|]
+
+log_sigmoid_forward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+log_sigmoid_forward_out_ttt _output _buffer _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::log_sigmoid_forward_out(
+    *$(at::Tensor* _output)
+  , *$(at::Tensor* _buffer)
+  , *$(at::Tensor* _self)));
+  }|]
+
+log_sigmoid_forward_t
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+log_sigmoid_forward_t _self =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::log_sigmoid_forward(
+    *$(at::Tensor* _self)));
+  }|]
+
+log_sigmoid_backward_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+log_sigmoid_backward_out_tttt _grad_input _grad_output _self _buffer =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_sigmoid_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _buffer)));
+  }|]
+
+log_sigmoid_backward_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+log_sigmoid_backward_ttt _grad_output _self _buffer =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::log_sigmoid_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _buffer)));
+  }|]
+
+rrelu_with_noise_out_tttssbG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+rrelu_with_noise_out_tttssbG _out _self _noise _lower _upper _training _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)
+  , *$(at::Generator* _generator)));
+  }|]
+
+rrelu_with_noise_out_tttssb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+rrelu_with_noise_out_tttssb _out _self _noise _lower _upper _training =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)));
+  }|]
+
+rrelu_with_noise_out_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu_with_noise_out_tttss _out _self _noise _lower _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)));
+  }|]
+
+rrelu_with_noise_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu_with_noise_out_ttts _out _self _noise _lower =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)));
+  }|]
+
+rrelu_with_noise_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rrelu_with_noise_out_ttt _out _self _noise =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)));
+  }|]
+
+rrelu_with_noise_ttssbG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+rrelu_with_noise_ttssbG _self _noise _lower _upper _training _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)
+  , *$(at::Generator* _generator)));
+  }|]
+
+rrelu_with_noise_ttssb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+rrelu_with_noise_ttssb _self _noise _lower _upper _training =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)));
+  }|]
+
+rrelu_with_noise_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu_with_noise_ttss _self _noise _lower _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)));
+  }|]
+
+rrelu_with_noise_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu_with_noise_tts _self _noise _lower =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)));
+  }|]
+
+rrelu_with_noise_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rrelu_with_noise_tt _self _noise =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)));
+  }|]
+
+rrelu_with_noise_backward_tttssbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+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 _self_is_result)));
+  }|]
+
+rrelu_with_noise__ttssbG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+rrelu_with_noise__ttssbG _self _noise _lower _upper _training _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)
+  , *$(at::Generator* _generator)));
+  }|]
+
+rrelu_with_noise__ttssb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+rrelu_with_noise__ttssb _self _noise _lower _upper _training =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)
+  , $(bool _training)));
+  }|]
+
+rrelu_with_noise__ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu_with_noise__ttss _self _noise _lower _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)
+  , *$(at::Scalar* _upper)));
+  }|]
+
+rrelu_with_noise__tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+rrelu_with_noise__tts _self _noise _lower =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)
+  , *$(at::Scalar* _lower)));
+  }|]
+
+rrelu_with_noise__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+rrelu_with_noise__tt _self _noise =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rrelu_with_noise_(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _noise)));
+  }|]
+
+softplus_out_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softplus_out_ttss _out _self _beta _threshold =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _threshold)));
+  }|]
+
+softplus_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softplus_out_tts _out _self _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+softplus_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+softplus_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+softplus_tss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softplus_tss _self _beta _threshold =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _threshold)));
+  }|]
+
+softplus_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softplus_ts _self _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _beta)));
+  }|]
+
+softplus_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+softplus_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus(
+    *$(at::Tensor* _self)));
+  }|]
+
+softplus_backward_out_tttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softplus_backward_out_tttss _grad_input _grad_output _self _beta _threshold =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _threshold)));
+  }|]
+
+softplus_backward_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softplus_backward_ttss _grad_output _self _beta _threshold =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _threshold)));
+  }|]
+
+softshrink_out_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softshrink_out_tts _out _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softshrink_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+softshrink_out_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+softshrink_out_tt _out _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softshrink_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)));
+  }|]
+
+softshrink_ts
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softshrink_ts _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softshrink(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+softshrink_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+softshrink_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softshrink(
+    *$(at::Tensor* _self)));
+  }|]
+
+softshrink_backward_out_ttts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softshrink_backward_out_ttts _grad_input _grad_output _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softshrink_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+softshrink_backward_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+softshrink_backward_tts _grad_output _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softshrink_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+adaptive_avg_pool2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+adaptive_avg_pool2d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+adaptive_avg_pool2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+adaptive_avg_pool2d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+mkldnn_adaptive_avg_pool2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_adaptive_avg_pool2d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_adaptive_avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+mkldnn_adaptive_avg_pool2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+mkldnn_adaptive_avg_pool2d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_adaptive_avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+mkldnn_adaptive_avg_pool2d_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+mkldnn_adaptive_avg_pool2d_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_adaptive_avg_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_adaptive_avg_pool2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_adaptive_avg_pool2d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_adaptive_avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+_adaptive_avg_pool2d_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_adaptive_avg_pool2d_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_adaptive_avg_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+adaptive_avg_pool3d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+adaptive_avg_pool3d_out_ttl _out _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_avg_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+adaptive_avg_pool3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+adaptive_avg_pool3d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_avg_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+_adaptive_avg_pool3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_adaptive_avg_pool3d_tl _self _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_adaptive_avg_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+adaptive_avg_pool3d_backward_out_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+adaptive_avg_pool3d_backward_out_ttt _grad_input _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_avg_pool3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+_adaptive_avg_pool3d_backward_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+_adaptive_avg_pool3d_backward_tt _grad_output _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_adaptive_avg_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)));
+  }|]
+
+adaptive_max_pool2d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool2d_out_tttl _out _indices _self _output_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::adaptive_max_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+adaptive_max_pool2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool2d_tl _self _output_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::adaptive_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+adaptive_max_pool2d_backward_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+adaptive_max_pool2d_backward_out_tttt _grad_input _grad_output _self _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_max_pool2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+adaptive_max_pool2d_backward_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+adaptive_max_pool2d_backward_ttt _grad_output _self _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+adaptive_max_pool3d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool3d_out_tttl _out _indices _self _output_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::adaptive_max_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+adaptive_max_pool3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+adaptive_max_pool3d_tl _self _output_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::adaptive_max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+adaptive_max_pool3d_backward_out_tttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+adaptive_max_pool3d_backward_out_tttt _grad_input _grad_output _self _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_max_pool3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+adaptive_max_pool3d_backward_ttt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+adaptive_max_pool3d_backward_ttt _grad_output _self _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::adaptive_max_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+avg_pool2d_out_ttlllbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+avg_pool2d_out_ttlllbbl _out _self _kernel_size _stride _padding _ceil_mode _count_include_pad _divisor_override =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)
+  , $(int64_t _divisor_override)));
+  }|]
+
+avg_pool2d_out_ttlllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool2d_out_ttlllbb _out _self _kernel_size _stride _padding _ceil_mode _count_include_pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)));
+  }|]
+
+avg_pool2d_out_ttlllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool2d_out_ttlllb _out _self _kernel_size _stride _padding _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)));
+  }|]
+
+avg_pool2d_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool2d_out_ttlll _out _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+avg_pool2d_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool2d_out_ttll _out _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+avg_pool2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool2d_out_ttl _out _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+avg_pool2d_tlllbbl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+avg_pool2d_tlllbbl _self _kernel_size _stride _padding _ceil_mode _count_include_pad _divisor_override =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)
+  , $(int64_t _divisor_override)));
+  }|]
+
+avg_pool2d_tlllbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool2d_tlllbb _self _kernel_size _stride _padding _ceil_mode _count_include_pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)));
+  }|]
+
+avg_pool2d_tlllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool2d_tlllb _self _kernel_size _stride _padding _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)));
+  }|]
+
+avg_pool2d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool2d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+avg_pool2d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool2d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+avg_pool2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool2d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+avg_pool2d_backward_out_tttlllbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+avg_pool2d_backward_out_tttlllbbl _grad_input _grad_output _self _kernel_size _stride _padding _ceil_mode _count_include_pad _divisor_override =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)
+  , $(int64_t _divisor_override)));
+  }|]
+
+avg_pool2d_backward_ttlllbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+avg_pool2d_backward_ttlllbbl _grad_output _self _kernel_size _stride _padding _ceil_mode _count_include_pad _divisor_override =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)
+  , $(int64_t _divisor_override)));
+  }|]
+
+avg_pool3d_out_ttlllbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+avg_pool3d_out_ttlllbbl _out _self _kernel_size _stride _padding _ceil_mode _count_include_pad _divisor_override =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)
+  , $(int64_t _divisor_override)));
+  }|]
+
+avg_pool3d_out_ttlllbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool3d_out_ttlllbb _out _self _kernel_size _stride _padding _ceil_mode _count_include_pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)));
+  }|]
+
+avg_pool3d_out_ttlllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool3d_out_ttlllb _out _self _kernel_size _stride _padding _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)));
+  }|]
+
+avg_pool3d_out_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool3d_out_ttlll _out _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+avg_pool3d_out_ttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool3d_out_ttll _out _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+avg_pool3d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool3d_out_ttl _out _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+avg_pool3d_tlllbbl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+avg_pool3d_tlllbbl _self _kernel_size _stride _padding _ceil_mode _count_include_pad _divisor_override =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)
+  , $(int64_t _divisor_override)));
+  }|]
+
+avg_pool3d_tlllbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool3d_tlllbb _self _kernel_size _stride _padding _ceil_mode _count_include_pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)));
+  }|]
+
+avg_pool3d_tlllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+avg_pool3d_tlllb _self _kernel_size _stride _padding _ceil_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)));
+  }|]
+
+avg_pool3d_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool3d_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+avg_pool3d_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool3d_tll _self _kernel_size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+avg_pool3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+avg_pool3d_tl _self _kernel_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+avg_pool3d_backward_out_tttlllbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+avg_pool3d_backward_out_tttlllbbl _grad_input _grad_output _self _kernel_size _stride _padding _ceil_mode _count_include_pad _divisor_override =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)
+  , $(int64_t _divisor_override)));
+  }|]
+
+avg_pool3d_backward_ttlllbbl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+avg_pool3d_backward_ttlllbbl _grad_output _self _kernel_size _stride _padding _ceil_mode _count_include_pad _divisor_override =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::avg_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , $(bool _ceil_mode)
+  , $(bool _count_include_pad)
+  , $(int64_t _divisor_override)));
+  }|]
+
+fractional_max_pool2d_out_tttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+fractional_max_pool2d_out_tttllt _output _indices _self _kernel_size _output_size _random_samples =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fractional_max_pool2d_out(
+    *$(at::Tensor* _output)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(at::Tensor* _random_samples)));
+  }|]
+
+fractional_max_pool2d_tllt
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+fractional_max_pool2d_tllt _self _kernel_size _output_size _random_samples =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fractional_max_pool2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(at::Tensor* _random_samples)));
+  }|]
+
+fractional_max_pool2d_backward_out_tttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fractional_max_pool2d_backward_out_tttllt _grad_input _grad_output _self _kernel_size _output_size _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fractional_max_pool2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+fractional_max_pool2d_backward_ttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fractional_max_pool2d_backward_ttllt _grad_output _self _kernel_size _output_size _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fractional_max_pool2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+fractional_max_pool3d_out_tttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+fractional_max_pool3d_out_tttllt _output _indices _self _kernel_size _output_size _random_samples =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fractional_max_pool3d_out(
+    *$(at::Tensor* _output)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(at::Tensor* _random_samples)));
+  }|]
+
+fractional_max_pool3d_tllt
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+fractional_max_pool3d_tllt _self _kernel_size _output_size _random_samples =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fractional_max_pool3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(at::Tensor* _random_samples)));
+  }|]
+
+fractional_max_pool3d_backward_out_tttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fractional_max_pool3d_backward_out_tttllt _grad_input _grad_output _self _kernel_size _output_size _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fractional_max_pool3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+fractional_max_pool3d_backward_ttllt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+fractional_max_pool3d_backward_ttllt _grad_output _self _kernel_size _output_size _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::fractional_max_pool3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+max_pool2d_with_indices_out_tttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttllllb _out _indices _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool2d_with_indices_out_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttllll _out _indices _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool2d_with_indices_out_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttlll _out _indices _self _kernel_size _stride _padding =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool2d_with_indices_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttll _out _indices _self _kernel_size _stride =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool2d_with_indices_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_out_tttl _out _indices _self _kernel_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+max_pool2d_with_indices_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool2d_with_indices_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool2d_with_indices_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool2d_with_indices_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tll _self _kernel_size _stride =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool2d_with_indices_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool2d_with_indices_tl _self _kernel_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool2d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+max_pool2d_with_indices_backward_out_tttllllbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+max_pool2d_with_indices_backward_out_tttllllbt _grad_input _grad_output _self _kernel_size _stride _padding _dilation _ceil_mode _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_with_indices_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+max_pool2d_with_indices_backward_ttllllbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+max_pool2d_with_indices_backward_ttllllbt _grad_output _self _kernel_size _stride _padding _dilation _ceil_mode _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d_with_indices_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+max_pool3d_with_indices_out_tttllllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttllllb _out _indices _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool3d_with_indices_out_tttllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttllll _out _indices _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool3d_with_indices_out_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttlll _out _indices _self _kernel_size _stride _padding =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool3d_with_indices_out_tttll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttll _out _indices _self _kernel_size _stride =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool3d_with_indices_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_out_tttl _out _indices _self _kernel_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+max_pool3d_with_indices_tllllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tllllb _self _kernel_size _stride _padding _dilation _ceil_mode =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)));
+  }|]
+
+max_pool3d_with_indices_tllll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tllll _self _kernel_size _stride _padding _dilation =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)));
+  }|]
+
+max_pool3d_with_indices_tlll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tlll _self _kernel_size _stride _padding =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_pool3d_with_indices_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tll _self _kernel_size _stride =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+max_pool3d_with_indices_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+max_pool3d_with_indices_tl _self _kernel_size =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool3d_with_indices(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)));
+  }|]
+
+max_pool3d_with_indices_backward_out_tttllllbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+max_pool3d_with_indices_backward_out_tttllllbt _grad_input _grad_output _self _kernel_size _stride _padding _dilation _ceil_mode _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d_with_indices_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+max_pool3d_with_indices_backward_ttllllbt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+max_pool3d_with_indices_backward_ttllllbt _grad_output _self _kernel_size _stride _padding _dilation _ceil_mode _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d_with_indices_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _kernel_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)
+  , *$(std::vector<int64_t>* _dilation)
+  , $(bool _ceil_mode)
+  , *$(at::Tensor* _indices)));
+  }|]
+
+max_unpool2d_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_unpool2d_out_tttl _out _self _indices _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_unpool2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+max_unpool2d_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_unpool2d_ttl _self _indices _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_unpool2d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
+max_unpool3d_out_tttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_unpool3d_out_tttlll _out _self _indices _output_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_unpool3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+max_unpool3d_ttlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+max_unpool3d_ttlll _self _indices _output_size _stride _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_unpool3d(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _indices)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad1d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad1d_out_ttl _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad1d_tl _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad1d_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad1d_backward_out_tttl _grad_input _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad1d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad1d_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad1d_backward_ttl _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad1d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad2d_out_ttl _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad2d_tl _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad2d_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad2d_backward_out_tttl _grad_input _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad2d_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad2d_backward_ttl _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad3d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad3d_out_ttl _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad3d_tl _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad3d_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad3d_backward_out_tttl _grad_input _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+reflection_pad3d_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+reflection_pad3d_backward_ttl _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::reflection_pad3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad1d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad1d_out_ttl _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad1d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad1d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad1d_tl _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad1d_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad1d_backward_out_tttl _grad_input _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad1d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad1d_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad1d_backward_ttl _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad1d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad2d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad2d_out_ttl _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad2d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad2d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad2d_tl _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad2d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad2d_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad2d_backward_out_tttl _grad_input _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad2d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad2d_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad2d_backward_ttl _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad2d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad3d_out_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad3d_out_ttl _out _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad3d_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad3d_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad3d_tl _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad3d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad3d_backward_out_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad3d_backward_out_tttl _grad_input _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad3d_backward_out(
+    *$(at::Tensor* _grad_input)
+  , *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+replication_pad3d_backward_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+replication_pad3d_backward_ttl _grad_output _self _padding =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::replication_pad3d_backward(
+    *$(at::Tensor* _grad_output)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _padding)));
+  }|]
+
+_pad_circular_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_pad_circular_tl _self _pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pad_circular(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)));
+  }|]
+
+_pad_enum_tlld
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+_pad_enum_tlld _self _pad _mode _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pad_enum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)
+  , $(int64_t _mode)
+  , $(double _value)));
+  }|]
+
+_pad_enum_tll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+_pad_enum_tll _self _pad _mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pad_enum(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)
+  , $(int64_t _mode)));
+  }|]
+
+pad_tlsd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> CDouble
+  -> IO (Ptr Tensor)
+pad_tlsd _self _pad _mode _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pad(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)
+  , *$(std::string* _mode)
+  , $(double _value)));
+  }|]
+
+pad_tls
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+pad_tls _self _pad _mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pad(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)
+  , *$(std::string* _mode)));
+  }|]
+
+pad_tl
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+pad_tl _self _pad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pad(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _pad)));
+  }|]
+
+upsample_linear1d_tlba
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+upsample_linear1d_tlba _input _output_size _align_corners _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_linear1d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+upsample_bilinear2d_tlba
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+upsample_bilinear2d_tlba _input _output_size _align_corners _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bilinear2d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+_upsample_bilinear2d_aa_tlba
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_tlba _input _output_size _align_corners _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+upsample_trilinear3d_tlba
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+upsample_trilinear3d_tlba _input _output_size _align_corners _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_trilinear3d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+upsample_bicubic2d_tlba
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+upsample_bicubic2d_tlba _input _output_size _align_corners _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_bicubic2d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+_upsample_bicubic2d_aa_tlba
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_upsample_bicubic2d_aa_tlba _input _output_size _align_corners _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bicubic2d_aa(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+upsample_nearest1d_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+upsample_nearest1d_tla _input _output_size _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest1d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+_upsample_nearest_exact1d_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact1d_tla _input _output_size _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact1d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+upsample_nearest2d_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+upsample_nearest2d_tla _input _output_size _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest2d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+_upsample_nearest_exact2d_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact2d_tla _input _output_size _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact2d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+upsample_nearest3d_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+upsample_nearest3d_tla _input _output_size _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_nearest3d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+_upsample_nearest_exact3d_tla
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr (StdVector CDouble)
+  -> IO (Ptr Tensor)
+_upsample_nearest_exact3d_tla _input _output_size _scale_factors =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_nearest_exact3d(
+    *$(at::Tensor* _input)
+  , *$(std::vector<int64_t>* _output_size)
+  , *$(std::vector<double>* _scale_factors)));
+  }|]
+
+upsample_linear1d_out_ttlbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+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
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_linear1d_out_ttlb _out _self _output_size _align_corners =
+  [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)));
+  }|]
+
+upsample_linear1d_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_linear1d_tlb _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::upsample_linear1d(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(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
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_linear1d_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
+  [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)));
+  }|]
+
+upsample_linear1d_backward_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+upsample_linear1d_backward_tllb _grad_output _output_size _input_size _align_corners =
+  [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)));
+  }|]
+
+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_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)
+  , $(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_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_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_bilinear2d_aa_out_ttlbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_out_ttlbdd _out _self _output_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+_upsample_bilinear2d_aa_out_ttlbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_out_ttlbd _out _self _output_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)));
+  }|]
+
+_upsample_bilinear2d_aa_out_ttlb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_out_ttlb _out _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa_out(
+    *$(at::Tensor* _out)
+  , *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+_upsample_bilinear2d_aa_tlbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_tlbdd _self _output_size _align_corners _scales_h _scales_w =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)
+  , $(double _scales_h)
+  , $(double _scales_w)));
+  }|]
+
+-- _upsample_bilinear2d_aa_tlbd
+--   :: Ptr Tensor
+--   -> Ptr IntArray
+--   -> CBool
+--   -> CDouble
+--   -> IO (Ptr Tensor)
+-- _upsample_bilinear2d_aa_tlbd _self _output_size _align_corners _scales_h =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa(
+--     *$(at::Tensor* _self)
+--   , *$(std::vector<int64_t>* _output_size)
+--   , $(bool _align_corners)
+--   , $(double _scales_h)));
+--   }|]
+
+_upsample_bilinear2d_aa_tlb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_tlb _self _output_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa(
+    *$(at::Tensor* _self)
+  , *$(std::vector<int64_t>* _output_size)
+  , $(bool _align_corners)));
+  }|]
+
+_upsample_bilinear2d_aa_backward_out_ttllbdd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_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_aa_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_aa_backward_out_ttllbd
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_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_aa_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_aa_backward_out_ttllb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_backward_out_ttllb _grad_input _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa_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_aa_backward_tllbdd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_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_aa_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_aa_backward_tllbd
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_backward_tllbd _grad_output _output_size _input_size _align_corners _scales_h =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa_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_aa_backward_tllb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+_upsample_bilinear2d_aa_backward_tllb _grad_output _output_size _input_size _align_corners =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_upsample_bilinear2d_aa_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_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)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Optim.hs b/src/Torch/Internal/Unmanaged/Optim.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Optim.hs
@@ -0,0 +1,344 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module Torch.Internal.Unmanaged.Optim where
+
+import Control.Exception.Safe (bracket)
+import Foreign
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign.Ptr
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Types as C
+import Torch.Internal.Type
+import Torch.Internal.Unmanaged.Helper
+
+C.context $ C.cppCtx <> mempty {C.ctxTypesTable = typeTable}
+
+C.include "<fstream>"
+C.include "<vector>"
+C.include "<tuple>"
+
+C.include "hasktorch_profile.h"
+
+C.include "<torch/types.h>"
+
+C.include "<torch/optim.h>"
+
+C.include "<torch/serialize.h>"
+
+-- optimizerWithAdam
+--   :: CDouble
+--   -> CDouble
+--   -> CDouble
+--   -> CDouble
+--   -> CDouble
+--   -> CBool
+--   -> Ptr TensorList
+--   -> (Ptr TensorList -> IO (Ptr Tensor))
+--   -> CInt
+--   -> IO (Ptr TensorList)
+-- optimizerWithAdam adamLr adamBetas0 adamBetas1 adamEps adamWeightDecay adamAmsgrad initParams loss numIter =
+--   bracket
+--     (callbackHelper loss')
+--     freeHaskellFunPtr
+--     $ \funcPtr ->
+--       [C.throwBlock| std::vector<at::Tensor>* {
+--         std::vector<at::Tensor>* init_params = $(std::vector<at::Tensor>* initParams);
+--         std::vector<at::Tensor>* params = new std::vector<at::Tensor>();
+--         auto tfunc = $(void* (*funcPtr)(void*));
+--         for(int i=0;i<init_params->size();i++){
+--           params->push_back((*init_params)[i].detach().set_requires_grad(true));
+--         }
+--         auto options = torch::optim::AdamOptions()
+--           .lr($(double adamLr))
+--           .betas(std::make_tuple($(double adamBetas0),$(double adamBetas1)))
+--           .eps($(double adamEps))
+--           .weight_decay($(double adamWeightDecay))
+--           .amsgrad($(bool adamAmsgrad));
+--         torch::optim::Adam optimizer(*params, options);
+--         optimizer.zero_grad();
+--         typedef at::Tensor* (*Func)(std::vector<at::Tensor>*);
+--         auto func = (Func)tfunc;
+--         for(int i=0;i<$(int numIter);i++){
+--           auto loss = func(params);
+--           loss->backward();
+--           optimizer.step();
+--         }
+--         return params;
+--       }|]
+--   where
+--     loss' :: Ptr () -> IO (Ptr ())
+--     loss' params = castPtr <$> loss (castPtr params)
+
+
+adagrad
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> Ptr TensorList
+  -> IO (Ptr Optimizer)
+adagrad lr lr_decay weight_decay initial_accumulator_value eps initParams =
+  [C.throwBlock| torch::optim::Optimizer* {
+    std::vector<at::Tensor>* init_params = $(std::vector<at::Tensor>* initParams);
+    std::vector<at::Tensor> params;
+    for(int i=0;i<init_params->size();i++){
+      params.push_back((*init_params)[i].detach().set_requires_grad(true));
+    }
+    auto options = torch::optim::AdagradOptions()
+      .lr($(double lr))
+      .lr_decay($(double lr_decay))
+      .weight_decay($(double weight_decay))
+      .initial_accumulator_value($(double initial_accumulator_value))
+      .eps($(double eps));
+    torch::optim::Adagrad* optimizer = new torch::optim::Adagrad(params, options);
+    optimizer->zero_grad();
+    return dynamic_cast<torch::optim::Optimizer*>(optimizer);
+  }|]
+
+rmsprop
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> Ptr TensorList
+  -> IO (Ptr Optimizer)
+rmsprop lr alpha eps weight_decay momentum centered initParams =
+  [C.throwBlock| torch::optim::Optimizer* {
+    std::vector<at::Tensor>* init_params = $(std::vector<at::Tensor>* initParams);
+    std::vector<at::Tensor> params;
+    for(int i=0;i<init_params->size();i++){
+      params.push_back((*init_params)[i].detach().set_requires_grad(true));
+    }
+    auto options = torch::optim::RMSpropOptions()
+      .lr($(double lr))
+      .alpha($(double alpha))
+      .eps($(double eps))
+      .weight_decay($(double weight_decay))
+      .momentum($(double momentum))
+      .centered($(bool centered));
+    torch::optim::RMSprop* optimizer = new torch::optim::RMSprop(params, options);
+    optimizer->zero_grad();
+    return dynamic_cast<torch::optim::Optimizer*>(optimizer);
+  }|]
+
+sgd
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> Ptr TensorList
+  -> IO (Ptr Optimizer)
+sgd lr momentum dampening weight_decay nesterov initParams =
+  [C.throwBlock| torch::optim::Optimizer* {
+    std::vector<at::Tensor>* init_params = $(std::vector<at::Tensor>* initParams);
+    std::vector<at::Tensor> params;
+    for(int i=0;i<init_params->size();i++){
+      params.push_back((*init_params)[i].detach().set_requires_grad(true));
+    }
+    auto options = torch::optim::SGDOptions($(double lr))
+      .momentum($(double momentum))
+      .dampening($(double dampening))
+      .weight_decay($(double weight_decay))
+      .nesterov($(bool nesterov));
+    torch::optim::SGD* optimizer = new torch::optim::SGD(params, options);
+    optimizer->zero_grad();
+    return dynamic_cast<torch::optim::Optimizer*>(optimizer);
+  }|]
+
+adam
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> Ptr TensorList
+  -> IO (Ptr Optimizer)
+adam adamLr adamBetas0 adamBetas1 adamEps adamWeightDecay adamAmsgrad initParams =
+  [C.throwBlock| torch::optim::Optimizer* {
+    std::vector<at::Tensor>* init_params = $(std::vector<at::Tensor>* initParams);
+    std::vector<at::Tensor> params;
+    for(int i=0;i<init_params->size();i++){
+      params.push_back((*init_params)[i].detach().set_requires_grad(true));
+    }
+    auto options = torch::optim::AdamOptions()
+      .lr($(double adamLr))
+      .betas(std::make_tuple($(double adamBetas0),$(double adamBetas1)))
+      .eps($(double adamEps))
+      .weight_decay($(double adamWeightDecay))
+      .amsgrad($(bool adamAmsgrad));
+    torch::optim::Adam* optimizer = new torch::optim::Adam(params, options);
+    optimizer->zero_grad();
+    return dynamic_cast<torch::optim::Optimizer*>(optimizer);
+  }|]
+
+adamw
+  :: CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> Ptr TensorList
+  -> IO (Ptr Optimizer)
+adamw adamLr adamBetas0 adamBetas1 adamEps adamWeightDecay adamAmsgrad initParams =
+  [C.throwBlock| torch::optim::Optimizer* {
+    std::vector<at::Tensor>* init_params = $(std::vector<at::Tensor>* initParams);
+    std::vector<at::Tensor> params;
+    for(int i=0;i<init_params->size();i++){
+      params.push_back((*init_params)[i].detach().set_requires_grad(true));
+    }
+    auto options = torch::optim::AdamWOptions()
+      .lr($(double adamLr))
+      .betas(std::make_tuple($(double adamBetas0),$(double adamBetas1)))
+      .eps($(double adamEps))
+      .weight_decay($(double adamWeightDecay))
+      .amsgrad($(bool adamAmsgrad));
+    torch::optim::AdamW* optimizer = new torch::optim::AdamW(params, options);
+    optimizer->zero_grad();
+    return dynamic_cast<torch::optim::Optimizer*>(optimizer);
+  }|]
+
+
+lbfgs
+  :: CDouble
+  -> CInt
+  -> CInt
+  -> CDouble
+  -> CDouble
+  -> CInt
+  -> Maybe (Ptr StdString)
+  -> Ptr TensorList
+  -> IO (Ptr Optimizer)
+lbfgs lr max_iter max_eval tolerance_grad tolerance_change history_size Nothing initParams =
+  [C.throwBlock| torch::optim::Optimizer* {
+    std::vector<at::Tensor>* init_params = $(std::vector<at::Tensor>* initParams);
+    std::vector<at::Tensor> params;
+    for(int i=0;i<init_params->size();i++){
+      params.push_back((*init_params)[i].detach().set_requires_grad(true));
+    }
+    auto options = torch::optim::LBFGSOptions()
+      .lr($(double lr))
+      .max_iter($(int max_iter))
+      .max_eval($(int max_eval))
+      .tolerance_grad($(double tolerance_grad))
+      .tolerance_change($(double tolerance_change))
+      .history_size($(int history_size));
+    torch::optim::LBFGS* optimizer = new torch::optim::LBFGS(params, options);
+    optimizer->zero_grad();
+    return dynamic_cast<torch::optim::Optimizer*>(optimizer);
+  }|]
+lbfgs lr max_iter max_eval tolerance_grad tolerance_change history_size (Just line_search_fn) initParams =
+  [C.throwBlock| torch::optim::Optimizer* {
+    std::vector<at::Tensor>* init_params = $(std::vector<at::Tensor>* initParams);
+    std::vector<at::Tensor> params;
+    for(int i=0;i<init_params->size();i++){
+      params.push_back((*init_params)[i].detach().set_requires_grad(true));
+    }
+    auto options = torch::optim::LBFGSOptions()
+      .lr($(double lr))
+      .max_iter($(int max_iter))
+      .max_eval($(int max_eval))
+      .tolerance_grad($(double tolerance_grad))
+      .tolerance_change($(double tolerance_change))
+      .history_size($(int history_size))
+      .line_search_fn(*$(std::string* line_search_fn));
+    torch::optim::LBFGS* optimizer = new torch::optim::LBFGS(params, options);
+    optimizer->zero_grad();
+    return dynamic_cast<torch::optim::Optimizer*>(optimizer);
+  }|]
+
+getParams :: Ptr Optimizer -> IO (Ptr TensorList) 
+getParams optimizer =
+  [C.throwBlock| std::vector<at::Tensor>* {
+    return new std::vector<at::Tensor>($(torch::optim::Optimizer* optimizer)->param_groups().at(0).params());
+  }|]
+
+step :: Ptr Optimizer -> (Ptr TensorList -> IO (Ptr Tensor)) -> IO (Ptr Tensor)
+step optimizer lossFunc =
+  bracket
+    (callbackHelper lossFunc')
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [C.throwBlock| at::Tensor* {
+        auto tfunc = $(void* (*funcPtr)(void*));
+        auto optimizer = $(torch::optim::Optimizer* optimizer);
+        typedef at::Tensor* (*Func)(std::vector<at::Tensor>*);
+        auto func = (Func)tfunc;
+        auto v = optimizer->step([&]{
+          optimizer->zero_grad();
+          auto loss = func(&(optimizer->param_groups().at(0).params()));
+          loss->backward();
+          return *loss;
+        });
+        return new at::Tensor(v);
+      }|]
+  where
+    lossFunc' :: Ptr () -> IO (Ptr ())
+    lossFunc' params = castPtr <$> lossFunc (castPtr params)
+
+stepWithGenerator :: Ptr Optimizer -> Ptr Generator -> (Ptr TensorList -> Ptr Generator -> IO (Ptr (StdTuple '(Tensor,Generator)))) -> IO (Ptr (StdTuple '(Tensor,Generator)))
+stepWithGenerator optimizer generator lossFunc =
+  bracket
+    (callbackHelper2 lossFunc')
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [C.throwBlock| std::tuple<at::Tensor,at::Generator>* {
+        auto tfunc = $(void* (*funcPtr)(void*,void*));
+        auto optimizer = $(torch::optim::Optimizer* optimizer);
+        typedef std::tuple<at::Tensor,at::Generator>* (*Func)(std::vector<at::Tensor>*,at::Generator*);
+        auto generator = $(at::Generator* generator)->clone();
+        auto func = (Func)tfunc;
+        auto v = optimizer->step([&]{
+          optimizer->zero_grad();
+          auto lossWithGenerator = func(&(optimizer->param_groups().at(0).params()),&generator);
+          auto loss = std::get<0>(*lossWithGenerator);
+          generator = std::get<1>(*lossWithGenerator);
+          loss.backward();
+          return loss;
+        });
+        return new std::tuple<at::Tensor,at::Generator>(std::make_tuple(v,generator));
+      }|]
+  where
+    lossFunc' :: Ptr () -> Ptr () -> IO (Ptr ())
+    lossFunc' params generator = castPtr <$> lossFunc (castPtr params) (castPtr generator)
+
+-- After this function is called, params(TensorList) of optimizer is updated.
+-- TensorList of output is the same as optimizer's params(TensorList).
+unsafeStep :: Ptr Optimizer -> Ptr Tensor -> IO (Ptr TensorList)
+unsafeStep optimizer loss =
+  [C.throwBlock| std::vector<at::Tensor>* {
+    auto optimizer = $(torch::optim::Optimizer* optimizer);
+    auto loss = $(at::Tensor* loss);
+    optimizer->zero_grad();
+    loss->backward();
+    optimizer->step();
+    return new std::vector<at::Tensor>(optimizer->param_groups().at(0).params());
+  }|]
+
+save :: Ptr Optimizer -> Ptr StdString -> IO ()
+save optimizer filename =
+  [C.throwBlock| void {
+    std::ofstream output(*$(std::string* filename));
+    torch::save(*$(torch::optim::Optimizer* optimizer),output);
+  }|]
+
+load :: Ptr Optimizer -> Ptr StdString -> IO ()
+load optimizer filename =
+  [C.throwBlock| void {
+    std::ifstream input(*$(std::string* filename));
+    torch::load(*$(torch::optim::Optimizer* optimizer),input);
+  }|]
diff --git a/src/Torch/Internal/Unmanaged/Serialize.hs b/src/Torch/Internal/Unmanaged/Serialize.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Serialize.hs
@@ -0,0 +1,52 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.Serialize where
+
+import Foreign.Ptr
+import Foreign.C.String
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<fstream>"
+C.include "hasktorch_profile.h"
+C.include "<torch/serialize.h>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/core/ivalue.h>"
+
+save :: Ptr TensorList -> FilePath -> IO ()
+save inputs file = withCString file $ \cfile -> [C.throwBlock| void {
+    torch::save(*$(std::vector<at::Tensor>* inputs),$(char* cfile));
+  }|]
+
+load :: FilePath -> IO (Ptr TensorList)
+load file = withCString file $ \cfile -> [C.throwBlock| std::vector<at::Tensor>* {
+    std::vector<at::Tensor> tensor_vec;                                                
+    torch::load(tensor_vec,$(char* cfile));
+    return new std::vector<at::Tensor>(tensor_vec);
+  }|]
+
+pickleSave :: Ptr IValue -> FilePath -> IO ()
+pickleSave inputs file = withCString file $ \cfile -> [C.throwBlock| void {
+    auto output = torch::pickle_save(*$(at::IValue* inputs));
+    auto fout = std::ofstream($(char* cfile), std::ios::out | std::ofstream::binary);
+    std::copy(output.begin(), output.end(), std::ostreambuf_iterator<char>(fout));
+  }|]
+
+pickleLoad :: FilePath -> IO (Ptr IValue)
+pickleLoad file = withCString file $ \cfile -> [C.throwBlock| at::IValue* {
+    auto fin = std::ifstream($(char* cfile), std::ios::in | std::ifstream::binary);
+    const std::vector<char> input = std::vector<char>(std::istreambuf_iterator<char>(fin), std::istreambuf_iterator<char>());
+    return new at::IValue(torch::pickle_load(input));
+  }|]
diff --git a/src/Torch/Internal/Unmanaged/TensorFactories.hs b/src/Torch/Internal/Unmanaged/TensorFactories.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/TensorFactories.hs
@@ -0,0 +1,2186 @@
+
+-- generated by using spec/Declarations.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Torch.Internal.Unmanaged.TensorFactories where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<vector>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+
+C.include "<torch/csrc/autograd/generated/variable_factories.h>"
+
+
+_cudnn_init_dropout_state_dblo
+  :: CDouble
+  -> CBool
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_cudnn_init_dropout_state_dblo _dropout _train _dropout_seed _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_cudnn_init_dropout_state(
+    $(double _dropout)
+  , $(bool _train)
+  , $(int64_t _dropout_seed)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+arange_so
+  :: Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+arange_so _end _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::arange(
+    *$(at::Scalar* _end)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+arange_s
+  :: Ptr Scalar
+  -> IO (Ptr Tensor)
+arange_s _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::arange(
+    *$(at::Scalar* _end)));
+  }|]
+
+arange_sso
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+arange_sso _start _end _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::arange(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+arange_ss
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+arange_ss _start _end =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::arange(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)));
+  }|]
+
+arange_ssso
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+arange_ssso _start _end _step _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::arange(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+arange_sss
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+arange_sss _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::arange(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)));
+  }|]
+
+bartlett_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+bartlett_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::bartlett_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+bartlett_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+bartlett_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::bartlett_window(
+    $(int64_t _window_length)));
+  }|]
+
+bartlett_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+bartlett_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::bartlett_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+bartlett_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+bartlett_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::bartlett_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+blackman_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+blackman_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::blackman_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+blackman_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+blackman_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::blackman_window(
+    $(int64_t _window_length)));
+  }|]
+
+blackman_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+blackman_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::blackman_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+blackman_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+blackman_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::blackman_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+empty_lNoM
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_lNoM _size _names _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+empty_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+empty_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+empty_loM
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_loM _size _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+empty_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+empty_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+_empty_affine_quantized_lodlM
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> CDouble
+  -> Int64
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_lodlM _size _options _scale _zero_point _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)
+  , $(double _scale)
+  , $(int64_t _zero_point)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_empty_affine_quantized_lodl
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> CDouble
+  -> Int64
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_lodl _size _options _scale _zero_point =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)
+  , $(double _scale)
+  , $(int64_t _zero_point)));
+  }|]
+
+_empty_affine_quantized_lod
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> CDouble
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_lod _size _options _scale =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)
+  , $(double _scale)));
+  }|]
+
+_empty_affine_quantized_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_empty_affine_quantized_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+_empty_affine_quantized_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_empty_affine_quantized(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+_empty_per_channel_affine_quantized_lttloM
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_empty_per_channel_affine_quantized_lttloM _size _scales _zero_points _axis _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_empty_per_channel_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_empty_per_channel_affine_quantized_lttlo
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_empty_per_channel_affine_quantized_lttlo _size _scales _zero_points _axis _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_empty_per_channel_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_empty_per_channel_affine_quantized_lttl
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+_empty_per_channel_affine_quantized_lttl _size _scales _zero_points _axis =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_empty_per_channel_affine_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _scales)
+  , *$(at::Tensor* _zero_points)
+  , $(int64_t _axis)));
+  }|]
+
+empty_quantized_ltoM
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_quantized_ltoM _size _qtensor _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _qtensor)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_quantized_lto
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_quantized_lto _size _qtensor _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _qtensor)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+empty_quantized_lt
+  :: Ptr IntArray
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+empty_quantized_lt _size _qtensor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty_quantized(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _qtensor)));
+  }|]
+
+empty_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+empty_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+empty_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+empty_strided_llo _size _stride _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty_strided(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+empty_strided_ll
+  :: Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+empty_strided_ll _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::empty_strided(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+eye_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+eye_lo _n _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::eye(
+    $(int64_t _n)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+eye_l
+  :: Int64
+  -> IO (Ptr Tensor)
+eye_l _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::eye(
+    $(int64_t _n)));
+  }|]
+
+eye_llo
+  :: Int64
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+eye_llo _n _m _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::eye(
+    $(int64_t _n)
+  , $(int64_t _m)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+eye_ll
+  :: Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+eye_ll _n _m =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::eye(
+    $(int64_t _n)
+  , $(int64_t _m)));
+  }|]
+
+full_lsNo
+  :: Ptr IntArray
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+full_lsNo _size _fill_value _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+full_lsN
+  :: Ptr IntArray
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+full_lsN _size _fill_value _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+full_lso
+  :: Ptr IntArray
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+full_lso _size _fill_value _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+full_ls
+  :: Ptr IntArray
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+full_ls _size _fill_value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)));
+  }|]
+
+full_like_tsoM
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+full_like_tsoM _self _fill_value _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::full_like(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _fill_value)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+full_like_tso
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+full_like_tso _self _fill_value _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::full_like(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _fill_value)
+  , *$(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
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+from_file_sblo _filename _shared _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::from_file(
+    *$(std::string* _filename)
+  , $(bool _shared)
+  , $(int64_t _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+from_file_sbl
+  :: Ptr StdString
+  -> CBool
+  -> Int64
+  -> IO (Ptr Tensor)
+from_file_sbl _filename _shared _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::from_file(
+    *$(std::string* _filename)
+  , $(bool _shared)
+  , $(int64_t _size)));
+  }|]
+
+from_file_sb
+  :: Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+from_file_sb _filename _shared =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::from_file(
+    *$(std::string* _filename)
+  , $(bool _shared)));
+  }|]
+
+from_file_s
+  :: Ptr StdString
+  -> IO (Ptr Tensor)
+from_file_s _filename =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::from_file(
+    *$(std::string* _filename)));
+  }|]
+
+hann_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hann_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hann_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hann_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+hann_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hann_window(
+    $(int64_t _window_length)));
+  }|]
+
+hann_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hann_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hann_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hann_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+hann_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hann_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+hamming_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hamming_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hamming_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hamming_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+hamming_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hamming_window(
+    $(int64_t _window_length)));
+  }|]
+
+hamming_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hamming_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hamming_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+hamming_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+hamming_window_lbdo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hamming_window_lbdo _window_length _periodic _alpha _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hamming_window_lbd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+hamming_window_lbd _window_length _periodic _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)));
+  }|]
+
+hamming_window_lbddo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+hamming_window_lbddo _window_length _periodic _alpha _beta _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)
+  , $(double _beta)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+hamming_window_lbdd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+hamming_window_lbdd _window_length _periodic _alpha _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::hamming_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _alpha)
+  , $(double _beta)));
+  }|]
+
+kaiser_window_lo
+  :: Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+kaiser_window_lo _window_length _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::kaiser_window(
+    $(int64_t _window_length)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+kaiser_window_l
+  :: Int64
+  -> IO (Ptr Tensor)
+kaiser_window_l _window_length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::kaiser_window(
+    $(int64_t _window_length)));
+  }|]
+
+kaiser_window_lbo
+  :: Int64
+  -> CBool
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+kaiser_window_lbo _window_length _periodic _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::kaiser_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+kaiser_window_lb
+  :: Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+kaiser_window_lb _window_length _periodic =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::kaiser_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)));
+  }|]
+
+kaiser_window_lbdo
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+kaiser_window_lbdo _window_length _periodic _beta _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::kaiser_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _beta)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+kaiser_window_lbd
+  :: Int64
+  -> CBool
+  -> CDouble
+  -> IO (Ptr Tensor)
+kaiser_window_lbd _window_length _periodic _beta =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::kaiser_window(
+    $(int64_t _window_length)
+  , $(bool _periodic)
+  , $(double _beta)));
+  }|]
+
+linspace_sslo
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+linspace_sslo _start _end _steps _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::linspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+linspace_ssl
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr Tensor)
+linspace_ssl _start _end _steps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::linspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)));
+  }|]
+
+logspace_ssldo
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+logspace_ssldo _start _end _steps _base _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::logspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)
+  , $(double _base)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+logspace_ssld
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+logspace_ssld _start _end _steps _base =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::logspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)
+  , $(double _base)));
+  }|]
+
+logspace_ssl
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Int64
+  -> IO (Ptr Tensor)
+logspace_ssl _start _end _steps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::logspace(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , $(int64_t _steps)));
+  }|]
+
+ones_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+ones_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::ones(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+ones_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+ones_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::ones(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+ones_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+ones_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::ones(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+ones_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+ones_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::ones(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+ones_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+ones_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::ones_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+ones_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+ones_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::ones_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> IO (Ptr Tensor)
+scalar_tensor_so _s _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::scalar_tensor(
+    *$(at::Scalar* _s)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+scalar_tensor_s
+  :: Ptr Scalar
+  -> IO (Ptr Tensor)
+scalar_tensor_s _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::scalar_tensor(
+    *$(at::Scalar* _s)));
+  }|]
+
+rand_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+rand_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+rand_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+rand_lGNo
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_lGNo _size _generator _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+rand_lGN
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+rand_lGN _size _generator _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+rand_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+rand_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+rand_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+rand_lGo
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_lGo _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+rand_lG
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+rand_lG _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+rand_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+rand_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+rand_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+rand_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::rand_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_llo _high _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint(
+    $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randint_ll
+  :: Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+randint_ll _high _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint(
+    $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+randint_llGo
+  :: Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_llGo _high _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint(
+    $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randint_llG
+  :: Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randint_llG _high _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint(
+    $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randint_lllo
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_lllo _low _high _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint(
+    $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randint_lll
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+randint_lll _low _high _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint(
+    $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+randint_lllGo
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_lllGo _low _high _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint(
+    $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randint_lllG
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randint_lllG _low _high _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint(
+    $(int64_t _low)
+  , $(int64_t _high)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randint_like_tloM
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+randint_like_tloM _self _high _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint_like(
+    *$(at::Tensor* _self)
+  , $(int64_t _high)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+randint_like_tlo
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randint_like_tlo _self _high _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randint_like(
+    *$(at::Tensor* _self)
+  , $(int64_t _high)
+  , *$(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
+  -> Int64
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+randint_like_tlloM _self _low _high _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::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(torch::randint_like(
+    *$(at::Tensor* _self)
+  , $(int64_t _low)
+  , $(int64_t _high)
+  , *$(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
+  -> IO (Ptr Tensor)
+randn_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randn_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+randn_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+randn_lGo
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_lGo _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randn_lG
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randn_lG _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+randn_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randn_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+randn_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+randn_lGNo
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_lGNo _size _generator _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randn_lGN
+  :: Ptr IntArray
+  -> Ptr Generator
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+randn_lGN _size _generator _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+randn_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+randn_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+randn_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randn_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randn_like(
+    *$(at::Tensor* _self)
+  , *$(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
+  -> IO (Ptr Tensor)
+randperm_lo _n _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randperm(
+    $(int64_t _n)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randperm_l
+  :: Int64
+  -> IO (Ptr Tensor)
+randperm_l _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randperm(
+    $(int64_t _n)));
+  }|]
+
+randperm_lGo
+  :: Int64
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+randperm_lGo _n _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randperm(
+    $(int64_t _n)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+randperm_lG
+  :: Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+randperm_lG _n _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::randperm(
+    $(int64_t _n)
+  , *$(at::Generator* _generator)));
+  }|]
+
+range_ssso
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+range_ssso _start _end _step _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::range(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+range_sss
+  :: Ptr Scalar
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+range_sss _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::range(
+    *$(at::Scalar* _start)
+  , *$(at::Scalar* _end)
+  , *$(at::Scalar* _step)));
+  }|]
+
+zeros_lNo
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+zeros_lNo _size _names _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::zeros(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+zeros_lN
+  :: Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+zeros_lN _size _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::zeros(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+_efficientzerotensor_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_efficientzerotensor_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_efficientzerotensor(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_efficientzerotensor_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+_efficientzerotensor_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_efficientzerotensor(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+zeros_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+zeros_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::zeros(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+zeros_l
+  :: Ptr IntArray
+  -> IO (Ptr Tensor)
+zeros_l _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::zeros(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+zeros_like_toM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+zeros_like_toM _self _options _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::zeros_like(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+zeros_like_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+zeros_like_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::zeros_like(
+    *$(at::Tensor* _self)
+  , *$(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_compressed_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_compressed_tensor_tttlo _compressed_indices _plain_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_compressed_tensor(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_csr_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_csr_tensor_tttlo _crow_indices _col_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_csr_tensor(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_csc_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_csc_tensor_tttlo _ccol_indices _row_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_csc_tensor(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_bsr_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_bsr_tensor_tttlo _crow_indices _col_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_bsr_tensor(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_bsc_tensor_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_bsc_tensor_tttlo _ccol_indices _row_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_bsc_tensor(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_compressed_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_compressed_tensor_ttto _compressed_indices _plain_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_compressed_tensor(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_csr_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_csr_tensor_ttto _crow_indices _col_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_csr_tensor(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_csc_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_csc_tensor_ttto _ccol_indices _row_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_csc_tensor(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_bsr_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_bsr_tensor_ttto _crow_indices _col_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_bsr_tensor(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_bsc_tensor_ttto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_bsc_tensor_ttto _ccol_indices _row_indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_bsc_tensor(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_compressed_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_compressed_tensor_unsafe_tttlo _compressed_indices _plain_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_compressed_tensor_unsafe(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_compressed_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_compressed_tensor_unsafe_tttl _compressed_indices _plain_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_compressed_tensor_unsafe(
+    *$(at::Tensor* _compressed_indices)
+  , *$(at::Tensor* _plain_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_csr_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_csr_tensor_unsafe_tttlo _crow_indices _col_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_csr_tensor_unsafe(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_csr_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_csr_tensor_unsafe_tttl _crow_indices _col_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_csr_tensor_unsafe(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_csc_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_csc_tensor_unsafe_tttlo _ccol_indices _row_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_csc_tensor_unsafe(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_csc_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_csc_tensor_unsafe_tttl _ccol_indices _row_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_csc_tensor_unsafe(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_bsr_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_bsr_tensor_unsafe_tttlo _crow_indices _col_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_bsr_tensor_unsafe(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_bsr_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_bsr_tensor_unsafe_tttl _crow_indices _col_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_bsr_tensor_unsafe(
+    *$(at::Tensor* _crow_indices)
+  , *$(at::Tensor* _col_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_bsc_tensor_unsafe_tttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_bsc_tensor_unsafe_tttlo _ccol_indices _row_indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_bsc_tensor_unsafe(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_bsc_tensor_unsafe_tttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_bsc_tensor_unsafe_tttl _ccol_indices _row_indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_bsc_tensor_unsafe(
+    *$(at::Tensor* _ccol_indices)
+  , *$(at::Tensor* _row_indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+sparse_coo_tensor_lo
+  :: Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_lo _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_coo_tensor(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_coo_tensor_tto
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_tto _indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_coo_tensor(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_coo_tensor_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_tt _indices _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_coo_tensor(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)));
+  }|]
+
+sparse_coo_tensor_ttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_ttlo _indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_coo_tensor(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+sparse_coo_tensor_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+sparse_coo_tensor_ttl _indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::sparse_coo_tensor(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_coo_tensor_unsafe_ttlo
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_unsafe_ttlo _indices _values _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_coo_tensor_unsafe(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_coo_tensor_unsafe_ttl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_unsafe_ttl _indices _values _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_coo_tensor_unsafe(
+    *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+_sparse_coo_tensor_with_dims_lllo
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_with_dims_lllo _sparse_dim _dense_dim _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_coo_tensor_with_dims(
+    $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_sparse_coo_tensor_with_dims_and_tensors_llltto
+  :: Int64
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_sparse_coo_tensor_with_dims_and_tensors_llltto _sparse_dim _dense_dim _size _indices _values _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_sparse_coo_tensor_with_dims_and_tensors(
+    $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Tensor* _indices)
+  , *$(at::Tensor* _values)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_to_copy_tobM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> CBool
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+_to_copy_tobM _self _options _non_blocking _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_to_copy(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(bool _non_blocking)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+_to_copy_tob
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> CBool
+  -> IO (Ptr Tensor)
+_to_copy_tob _self _options _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_to_copy(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)
+  , $(bool _non_blocking)));
+  }|]
+
+_to_copy_to
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+_to_copy_to _self _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_to_copy(
+    *$(at::Tensor* _self)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+_to_copy_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+_to_copy_t _self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::_to_copy(
+    *$(at::Tensor* _self)));
+  }|]
+
+tril_indices_lllo
+  :: Int64
+  -> Int64
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+tril_indices_lllo _row _col _offset _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::tril_indices(
+    $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+tril_indices_lll
+  :: Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tril_indices_lll _row _col _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::tril_indices(
+    $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)));
+  }|]
+
+tril_indices_ll
+  :: Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tril_indices_ll _row _col =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::tril_indices(
+    $(int64_t _row)
+  , $(int64_t _col)));
+  }|]
+
+triu_indices_lllo
+  :: Int64
+  -> Int64
+  -> Int64
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+triu_indices_lllo _row _col _offset _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::triu_indices(
+    $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+triu_indices_lll
+  :: Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+triu_indices_lll _row _col _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::triu_indices(
+    $(int64_t _row)
+  , $(int64_t _col)
+  , $(int64_t _offset)));
+  }|]
+
+triu_indices_ll
+  :: Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+triu_indices_ll _row _col =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::triu_indices(
+    $(int64_t _row)
+  , $(int64_t _col)));
+  }|]
+
+normal_ddlGo
+  :: CDouble
+  -> CDouble
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+normal_ddlGo _mean _std _size _generator _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::normal(
+    $(double _mean)
+  , $(double _std)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+normal_ddlG
+  :: CDouble
+  -> CDouble
+  -> Ptr IntArray
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+normal_ddlG _mean _std _size _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::normal(
+    $(double _mean)
+  , $(double _std)
+  , *$(std::vector<int64_t>* _size)
+  , *$(at::Generator* _generator)));
+  }|]
+
+normal_ddl
+  :: CDouble
+  -> CDouble
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+normal_ddl _mean _std _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::normal(
+    $(double _mean)
+  , $(double _std)
+  , *$(std::vector<int64_t>* _size)));
+  }|]
+
+fft_fftfreq_ldo
+  :: Int64
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+fft_fftfreq_ldo _n _d _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::fft_fftfreq(
+    $(int64_t _n)
+  , $(double _d)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+fft_fftfreq_ld
+  :: Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+fft_fftfreq_ld _n _d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::fft_fftfreq(
+    $(int64_t _n)
+  , $(double _d)));
+  }|]
+
+fft_fftfreq_l
+  :: Int64
+  -> IO (Ptr Tensor)
+fft_fftfreq_l _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::fft_fftfreq(
+    $(int64_t _n)));
+  }|]
+
+fft_rfftfreq_ldo
+  :: Int64
+  -> CDouble
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+fft_rfftfreq_ldo _n _d _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::fft_rfftfreq(
+    $(int64_t _n)
+  , $(double _d)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+fft_rfftfreq_ld
+  :: Int64
+  -> CDouble
+  -> IO (Ptr Tensor)
+fft_rfftfreq_ld _n _d =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::fft_rfftfreq(
+    $(int64_t _n)
+  , $(double _d)));
+  }|]
+
+fft_rfftfreq_l
+  :: Int64
+  -> IO (Ptr Tensor)
+fft_rfftfreq_l _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(torch::fft_rfftfreq(
+    $(int64_t _n)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/C10Dict.hs b/src/Torch/Internal/Unmanaged/Type/C10Dict.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/C10Dict.hs
@@ -0,0 +1,69 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.C10Dict where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Control.Monad (forM)
+import Control.Exception.Safe (bracket)
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/core/Dict.h>"
+C.include "<vector>"
+
+newC10Dict :: Ptr IValue -> Ptr IValue -> IO (Ptr (C10Dict '(IValue,IValue)))
+newC10Dict key value = [C.throwBlock| c10::Dict<at::IValue,at::IValue>* {
+  return new c10::impl::GenericDict($(at::IValue* key)->type(),$(at::IValue* value)->type());
+}|]
+
+c10Dict_empty :: Ptr (C10Dict '(IValue,IValue)) -> IO (CBool)
+c10Dict_empty _obj = [C.throwBlock| bool { return (*$(c10::Dict<at::IValue,at::IValue>* _obj)).empty(); }|]
+
+c10Dict_size :: Ptr (C10Dict '(IValue,IValue)) -> IO (CSize)
+c10Dict_size _obj = [C.throwBlock| size_t { return (*$(c10::Dict<at::IValue,at::IValue>* _obj)).size(); }|]
+
+c10Dict_at :: Ptr (C10Dict '(IValue,IValue)) -> Ptr IValue -> IO (Ptr IValue)
+c10Dict_at _obj _s = [C.throwBlock| at::IValue* { return new at::IValue((*$(c10::Dict<at::IValue,at::IValue>* _obj)).at(*$(at::IValue* _s))); }|]
+
+c10Dict_insert :: Ptr (C10Dict '(IValue,IValue)) -> Ptr IValue  -> Ptr IValue -> IO ()
+c10Dict_insert _obj _key _value =
+  [C.throwBlock| void {
+    (*$(c10::Dict<at::IValue,at::IValue>* _obj)).insert(*$(at::IValue* _key),*$(at::IValue* _value));
+  }|]
+
+c10Dict_toList :: Ptr (C10Dict '(IValue,IValue)) -> IO [(Ptr IValue,Ptr IValue)]
+c10Dict_toList _obj = do
+  let new = [C.throwBlock| std::vector<std::array<at::IValue,2>>* {
+              auto obj = *$(c10::Dict<at::IValue,at::IValue>* _obj);
+              auto ret = new std::vector<std::array<at::IValue,2> >();
+              for(auto i = obj.begin() ; i != obj.end() ; i++){
+                ret->push_back({i->key(),i->value()});
+              }
+              return ret;
+             }|]
+      free dat = [C.throwBlock| void {
+              delete $(std::vector<std::array<at::IValue,2>>* dat);
+             }|]
+  bracket new free $ \dat -> do
+    size <- [C.throwBlock| int64_t { return (long int)$(std::vector<std::array<at::IValue,2>>* dat)->size();}|]
+    ret <- forM [0..(size-1)] $ \i -> do
+      key <- [C.throwBlock| at::IValue* { return new at::IValue($(std::vector<std::array<at::IValue,2>>* dat)->at($(int64_t i))[0]);}|]
+      val <- [C.throwBlock| at::IValue* { return new at::IValue($(std::vector<std::array<at::IValue,2>>* dat)->at($(int64_t i))[1]);}|]
+      return (key,val)
+    return ret
diff --git a/src/Torch/Internal/Unmanaged/Type/C10List.hs b/src/Torch/Internal/Unmanaged/Type/C10List.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/C10List.hs
@@ -0,0 +1,128 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.C10List where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/core/List.h>"
+C.include "<ATen/core/ivalue.h>"
+C.include "<vector>"
+
+newC10ListIValue :: Ptr IValue -> IO (Ptr (C10List IValue))
+newC10ListIValue elem = [C.throwBlock| c10::List<at::IValue>* { return new c10::impl::GenericList($(at::IValue* elem)->type()); }|]
+
+newC10ListTensor :: IO (Ptr (C10List Tensor))
+newC10ListTensor = [C.throwBlock| c10::List<at::Tensor>* { return new c10::List<at::Tensor>(); }|]
+
+newC10ListOptionalTensor :: IO (Ptr (C10List (C10Optional Tensor)))
+newC10ListOptionalTensor = [C.throwBlock| c10::List<c10::optional<at::Tensor>>* { return new c10::List<c10::optional<at::Tensor>>(); }|]
+
+newC10ListDouble :: IO (Ptr (C10List CDouble))
+newC10ListDouble = [C.throwBlock| c10::List<double>* { return new c10::List<double>(); }|]
+
+newC10ListInt :: IO (Ptr (C10List Int64))
+newC10ListInt = [C.throwBlock| c10::List<int64_t>* { return new c10::List<int64_t>(); }|]
+
+newC10ListBool :: IO (Ptr (C10List CBool))
+newC10ListBool = [C.throwBlock| c10::List<bool>* { return new c10::List<bool>(); }|]
+
+
+
+
+c10ListIValue_empty :: Ptr (C10List IValue) -> IO (CBool)
+c10ListIValue_empty _obj = [C.throwBlock| bool { return (*$(c10::List<at::IValue>* _obj)).empty(); }|]
+
+c10ListTensor_empty :: Ptr (C10List Tensor) -> IO (CBool)
+c10ListTensor_empty _obj = [C.throwBlock| bool { return (*$(c10::List<at::Tensor>* _obj)).empty(); }|]
+
+c10ListOptionalTensor_empty :: Ptr (C10List (C10Optional Tensor)) -> IO (CBool)
+c10ListOptionalTensor_empty _obj = [C.throwBlock| bool { return (*$(c10::List<c10::optional<at::Tensor>>* _obj)).empty(); }|]
+
+c10ListDouble_empty :: Ptr (C10List CDouble) -> IO (CBool)
+c10ListDouble_empty _obj = [C.throwBlock| bool { return (*$(c10::List<double>* _obj)).empty(); }|]
+
+c10ListInt_empty :: Ptr (C10List Int64) -> IO (CBool)
+c10ListInt_empty _obj = [C.throwBlock| bool { return (*$(c10::List<int64_t>* _obj)).empty(); }|]
+
+c10ListBool_empty :: Ptr (C10List CBool) -> IO (CBool)
+c10ListBool_empty _obj = [C.throwBlock| bool { return (*$(c10::List<bool>* _obj)).empty(); }|]
+
+c10ListIValue_size :: Ptr (C10List IValue) -> IO (CSize)
+c10ListIValue_size _obj = [C.throwBlock| size_t { return (*$(c10::List<at::IValue>* _obj)).size(); }|]
+
+c10ListTensor_size :: Ptr (C10List Tensor) -> IO (CSize)
+c10ListTensor_size _obj = [C.throwBlock| size_t { return (*$(c10::List<at::Tensor>* _obj)).size(); }|]
+
+c10ListOptionalTensor_size :: Ptr (C10List (C10Optional Tensor)) -> IO (CSize)
+c10ListOptionalTensor_size _obj = [C.throwBlock| size_t { return (*$(c10::List<c10::optional<at::Tensor>>* _obj)).size(); }|]
+
+c10ListDouble_size :: Ptr (C10List CDouble) -> IO (CSize)
+c10ListDouble_size _obj = [C.throwBlock| size_t { return (*$(c10::List<double>* _obj)).size(); }|]
+
+c10ListInt_size :: Ptr (C10List Int64) -> IO (CSize)
+c10ListInt_size _obj = [C.throwBlock| size_t { return (*$(c10::List<int64_t>* _obj)).size(); }|]
+
+c10ListBool_size :: Ptr (C10List CBool) -> IO (CSize)
+c10ListBool_size _obj = [C.throwBlock| size_t { return (*$(c10::List<bool>* _obj)).size(); }|]
+
+c10ListIValue_at :: Ptr (C10List IValue) -> CSize -> IO (Ptr IValue)
+c10ListIValue_at _obj _s = [C.throwBlock| at::IValue* { return new at::IValue((*$(c10::List<at::IValue>* _obj))[$(size_t _s)]); }|]
+
+c10ListTensor_at :: Ptr (C10List Tensor) -> CSize -> IO (Ptr Tensor)
+c10ListTensor_at _obj _s = [C.throwBlock| at::Tensor* { return new at::Tensor((*$(c10::List<at::Tensor>* _obj))[$(size_t _s)]); }|]
+
+c10ListOptionalTensor_at :: Ptr (C10List (C10Optional Tensor)) -> CSize -> IO (Ptr Tensor)
+c10ListOptionalTensor_at _obj _s = [C.throwBlock| at::Tensor* {
+    c10::List<c10::optional<at::Tensor>>& list = *$(c10::List<c10::optional<at::Tensor>>* _obj);
+    c10::optional<at::Tensor> v = list[$(size_t _s)];
+    return new at::Tensor(v.value());
+  }|]
+
+c10ListDouble_at :: Ptr (C10List CDouble) -> CSize -> IO CDouble
+c10ListDouble_at _obj _s = [C.throwBlock| double { return ((*$(c10::List<double>* _obj))[$(size_t _s)]); }|]
+
+c10ListInt_at :: Ptr (C10List Int64) -> CSize -> IO Int64
+c10ListInt_at _obj _s = [C.throwBlock| int64_t { return (int64_t)((*$(c10::List<int64_t>* _obj))[$(size_t _s)]); }|]
+
+c10ListBool_at :: Ptr (C10List CBool) -> CSize -> IO CBool
+c10ListBool_at _obj _s = [C.throwBlock| bool { return ((*$(c10::List<bool>* _obj))[$(size_t _s)]); }|]
+
+c10ListIValue_push_back :: Ptr (C10List IValue) -> Ptr IValue -> IO ()
+c10ListIValue_push_back _obj _v = [C.throwBlock| void {  (*$(c10::List<at::IValue>* _obj)).push_back(*$(at::IValue* _v)); }|]
+
+c10ListTensor_push_back :: Ptr (C10List Tensor) -> Ptr Tensor -> IO ()
+c10ListTensor_push_back _obj _v = [C.throwBlock| void {  (*$(c10::List<at::Tensor>* _obj)).push_back(*$(at::Tensor* _v)); }|]
+
+c10ListOptionalTensor_push_back :: Ptr (C10List (C10Optional Tensor)) -> Ptr Tensor -> IO ()
+c10ListOptionalTensor_push_back _obj _v = [C.throwBlock| void {  (*$(c10::List<c10::optional<at::Tensor>>* _obj)).push_back(*$(at::Tensor* _v)); }|]
+
+c10ListDouble_push_back :: Ptr (C10List CDouble) -> CDouble -> IO ()
+c10ListDouble_push_back _obj _v = [C.throwBlock| void {  (*$(c10::List<double>* _obj)).push_back($(double _v)); }|]
+
+c10ListInt_push_back :: Ptr (C10List Int64) -> Int64 -> IO ()
+c10ListInt_push_back _obj _v = [C.throwBlock| void {  (*$(c10::List<int64_t>* _obj)).push_back($(int64_t _v)); }|]
+
+c10ListBool_push_back :: Ptr (C10List CBool) -> CBool -> IO ()
+c10ListBool_push_back _obj _v = [C.throwBlock| void {  (*$(c10::List<bool>* _obj)).push_back($(bool _v)); }|]
+
+
+
diff --git a/src/Torch/Internal/Unmanaged/Type/C10Tuple.hs b/src/Torch/Internal/Unmanaged/Type/C10Tuple.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/C10Tuple.hs
@@ -0,0 +1,71 @@
+
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.C10Tuple where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/core/ivalue.h>"
+C.include "<vector>"
+
+
+
+newC10Tuple
+  :: IO (Ptr (C10Ptr IVTuple))
+newC10Tuple  =
+  [C.throwBlock| c10::intrusive_ptr<at::ivalue::Tuple>* { return new c10::intrusive_ptr<at::ivalue::Tuple>(
+    );
+  }|]
+
+newC10Tuple_tuple
+  :: Ptr IValueList
+  -> IO (Ptr (C10Ptr IVTuple))
+newC10Tuple_tuple _obj =
+  [C.throwBlock| c10::intrusive_ptr<at::ivalue::Tuple>* { return new c10::intrusive_ptr<at::ivalue::Tuple>(
+      at::ivalue::Tuple::create(*$(std::vector<at::IValue>* _obj))
+    );
+  }|]
+
+c10Tuple_empty
+  :: Ptr (C10Ptr IVTuple)
+  -> IO (CBool)
+c10Tuple_empty _obj =
+  [C.throwBlock| bool { return (*$(c10::intrusive_ptr<at::ivalue::Tuple>* _obj))->elements().empty(
+    );
+  }|]
+
+c10Tuple_size
+  :: Ptr (C10Ptr IVTuple)
+  -> IO (CSize)
+c10Tuple_size _obj =
+  [C.throwBlock| size_t { return (*$(c10::intrusive_ptr<at::ivalue::Tuple>* _obj))->elements().size(
+    );
+  }|]
+
+c10Tuple_at
+  :: Ptr (C10Ptr IVTuple)
+  -> CSize
+  -> IO (Ptr IValue)
+c10Tuple_at _obj _s =
+  [C.throwBlock| at::IValue* { return new at::IValue((*$(c10::intrusive_ptr<at::ivalue::Tuple>* _obj))->elements()[$(size_t _s)]);
+  }|]
diff --git a/src/Torch/Internal/Unmanaged/Type/Context.hs b/src/Torch/Internal/Unmanaged/Type/Context.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Context.hs
@@ -0,0 +1,110 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Context where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/Context.h>"
+C.include "<vector>"
+
+
+
+init
+  :: IO (())
+init  =
+  [C.throwBlock| void {  (at::init(
+    ));
+  }|]
+
+hasCUDA
+  :: IO (CBool)
+hasCUDA  =
+  [C.throwBlock| bool { return (at::hasCUDA(
+    ));
+  }|]
+
+hasHIP
+  :: IO (CBool)
+hasHIP  =
+  [C.throwBlock| bool { return (at::hasHIP(
+    ));
+  }|]
+
+hasXLA
+  :: IO (CBool)
+hasXLA  =
+  [C.throwBlock| bool { return (at::hasXLA(
+    ));
+  }|]
+
+getNumGPUs
+  :: IO (CSize)
+getNumGPUs  =
+  [C.throwBlock| size_t { return (at::getNumGPUs(
+    ));
+  }|]
+
+hasOpenMP
+  :: IO (CBool)
+hasOpenMP  =
+  [C.throwBlock| bool { return (at::hasOpenMP(
+    ));
+  }|]
+
+hasMKL
+  :: IO (CBool)
+hasMKL  =
+  [C.throwBlock| bool { return (at::hasMKL(
+    ));
+  }|]
+
+hasLAPACK
+  :: IO (CBool)
+hasLAPACK  =
+  [C.throwBlock| bool { return (at::hasLAPACK(
+    ));
+  }|]
+
+hasMAGMA
+  :: IO (CBool)
+hasMAGMA  =
+  [C.throwBlock| bool { return (at::hasMAGMA(
+    ));
+  }|]
+
+hasMKLDNN
+  :: IO (CBool)
+hasMKLDNN  =
+  [C.throwBlock| bool { return (at::hasMKLDNN(
+    ));
+  }|]
+
+manual_seed_L
+  :: Word64
+  -> IO (())
+manual_seed_L _seed =
+  [C.throwBlock| void {  (at::manual_seed(
+    $(uint64_t _seed)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Dimname.hs b/src/Torch/Internal/Unmanaged/Type/Dimname.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Dimname.hs
@@ -0,0 +1,100 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Dimname where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/core/Dimname.h>"
+C.include "<vector>"
+
+
+
+newDimname_n
+  :: Ptr Dimname
+  -> IO (Ptr Dimname)
+newDimname_n _x =
+  [C.throwBlock| at::Dimname* { return new at::Dimname(
+    *$(at::Dimname* _x));
+  }|]
+
+
+
+
+dimname_symbol
+  :: Ptr Dimname
+  -> IO (Ptr Symbol)
+dimname_symbol _obj =
+  [C.throwBlock| at::Symbol* { return new at::Symbol((*$(at::Dimname* _obj)).symbol(
+    ));
+  }|]
+
+dimname_isBasic
+  :: Ptr Dimname
+  -> IO (CBool)
+dimname_isBasic _obj =
+  [C.throwBlock| bool { return (*$(at::Dimname* _obj)).isBasic(
+    );
+  }|]
+
+dimname_isWildcard
+  :: Ptr Dimname
+  -> IO (CBool)
+dimname_isWildcard _obj =
+  [C.throwBlock| bool { return (*$(at::Dimname* _obj)).isWildcard(
+    );
+  }|]
+
+dimname_matches_n
+  :: Ptr Dimname
+  -> Ptr Dimname
+  -> IO (CBool)
+dimname_matches_n _obj _other =
+  [C.throwBlock| bool { return (*$(at::Dimname* _obj)).matches(
+    *$(at::Dimname* _other));
+  }|]
+
+
+
+fromSymbol_s
+  :: Ptr Symbol
+  -> IO (Ptr Dimname)
+fromSymbol_s _name =
+  [C.throwBlock| at::Dimname* { return new at::Dimname(at::Dimname::fromSymbol(
+    *$(at::Symbol* _name)));
+  }|]
+
+wildcard
+  :: IO (Ptr Dimname)
+wildcard  =
+  [C.throwBlock| at::Dimname* { return new at::Dimname(at::Dimname::wildcard(
+    ));
+  }|]
+
+isValidName_s
+  :: Ptr StdString
+  -> IO (CBool)
+isValidName_s _name =
+  [C.throwBlock| bool { return (at::Dimname::isValidName(
+    *$(std::string* _name)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/DimnameList.hs b/src/Torch/Internal/Unmanaged/Type/DimnameList.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/DimnameList.hs
@@ -0,0 +1,78 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.DimnameList where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/core/Dimname.h>"
+C.include "<vector>"
+
+
+
+newDimnameList
+  :: IO (Ptr DimnameList)
+newDimnameList  =
+  [C.throwBlock| std::vector<at::Dimname>* { return new std::vector<at::Dimname>(
+    );
+  }|]
+
+
+
+
+
+dimnameList_empty
+  :: Ptr DimnameList
+  -> IO (CBool)
+dimnameList_empty _obj =
+  [C.throwBlock| bool { return (*$(std::vector<at::Dimname>* _obj)).empty(
+    );
+  }|]
+
+dimnameList_size
+  :: Ptr DimnameList
+  -> IO (CSize)
+dimnameList_size _obj =
+  [C.throwBlock| size_t { return (*$(std::vector<at::Dimname>* _obj)).size(
+    );
+  }|]
+
+dimnameList_at_s
+  :: Ptr DimnameList
+  -> CSize
+  -> IO (Ptr Dimname)
+dimnameList_at_s _obj _s =
+  [C.throwBlock| at::Dimname* { return new at::Dimname((*$(std::vector<at::Dimname>* _obj)).at(
+    $(size_t _s)));
+  }|]
+
+dimnameList_push_back_n
+  :: Ptr DimnameList
+  -> Ptr Dimname
+  -> IO (())
+dimnameList_push_back_n _obj _v =
+  [C.throwBlock| void {  (*$(std::vector<at::Dimname>* _obj)).push_back(
+    *$(at::Dimname* _v));
+  }|]
+
+
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Extra.hs b/src/Torch/Internal/Unmanaged/Type/Extra.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Extra.hs
@@ -0,0 +1,163 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Extra where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Inline.Unsafe as CUnsafe
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/Functions.h>"
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/TensorOperators.h>"
+C.include "<vector>"
+C.include "<torch/csrc/autograd/generated/variable_factories.h>"
+
+tensor_assign1_l
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO ()
+tensor_assign1_l _obj _idx0 _val  =
+  [C.throwBlock| void { (*$(at::Tensor* _obj))[$(int64_t _idx0)] = $(int64_t _val); }|]
+
+tensor_assign2_l
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO ()
+tensor_assign2_l _obj _idx0 _idx1 _val  =
+  [C.throwBlock| void { (*$(at::Tensor* _obj))[$(int64_t _idx0)][$(int64_t _idx1)] = $(int64_t _val); }|]
+
+tensor_assign1_d
+  :: Ptr Tensor
+  -> Int64
+  -> CDouble
+  -> IO ()
+tensor_assign1_d _obj _idx0 _val  =
+  [C.throwBlock| void { (*$(at::Tensor* _obj))[$(int64_t _idx0)] = $(double _val); }|]
+
+tensor_assign2_d
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CDouble
+  -> IO ()
+tensor_assign2_d _obj _idx0 _idx1 _val  =
+  [C.throwBlock| void { (*$(at::Tensor* _obj))[$(int64_t _idx0)][$(int64_t _idx1)] = $(double _val); }|]
+
+
+tensor_assign1_t
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO ()
+tensor_assign1_t _obj _idx0 _val  =
+  [C.throwBlock| void { (*$(at::Tensor* _obj))[$(int64_t _idx0)] = *$(at::Tensor* _val); }|]
+
+tensor_assign2_t
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> IO ()
+tensor_assign2_t _obj _idx0 _idx1 _val  =
+  [C.throwBlock| void { (*$(at::Tensor* _obj))[$(int64_t _idx0)][$(int64_t _idx1)] = *$(at::Tensor* _val); }|]
+
+
+tensor_names
+  :: Ptr Tensor
+  -> IO (Ptr DimnameList)
+tensor_names _obj =
+  [C.throwBlock| std::vector<at::Dimname>* {
+      auto ref = (*$(at::Tensor* _obj)).names();
+      std::vector<at::Dimname>* vec = new std::vector<at::Dimname>();
+      for(int i=0;i<ref.size();i++){
+        vec->push_back(ref[i]);
+      }
+      return vec;
+  }|]
+
+tensor_to_device
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_to_device reference input =
+  [C.throwBlock| at::Tensor* {
+      auto d = (*$(at::Tensor* reference)).device();
+      return new at::Tensor((*$(at::Tensor* input)).to(d));
+  }|]
+
+new_empty_tensor
+  :: [Int]
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+new_empty_tensor [x] _options = do
+  let x' = fromIntegral x
+  [C.throwBlock| at::Tensor* {
+    return new at::Tensor(torch::empty({$(int x')}, *$(at::TensorOptions* _options)));
+  }|]
+
+new_empty_tensor [x,y] _options = do
+  let x' = fromIntegral x
+      y' = fromIntegral y
+  [C.throwBlock| at::Tensor* {
+    return new at::Tensor(torch::empty({$(int x'),$(int y')}, *$(at::TensorOptions* _options)));
+  }|]
+
+new_empty_tensor [x,y,z] _options = do
+  let x' = fromIntegral x
+      y' = fromIntegral y
+      z' = fromIntegral z
+  [C.throwBlock| at::Tensor* {
+    return new at::Tensor(torch::empty({$(int x'),$(int y'),$(int z')}, *$(at::TensorOptions* _options)));
+  }|]
+
+new_empty_tensor _size _options = do
+  let len = fromIntegral $ length _size
+  shape <- [C.throwBlock| std::vector<int64_t>* {
+    return new std::vector<int64_t>($(int len));
+  }|]
+  ptr <- [C.throwBlock| int64_t* {
+    return $(std::vector<int64_t>* shape)->data();
+  }|]
+  pokeArray ptr (map fromIntegral _size)
+
+  [C.throwBlock| at::Tensor* {
+    auto v = new at::Tensor(torch::empty(*$(std::vector<int64_t>* shape), *$(at::TensorOptions* _options)));
+    delete $(std::vector<int64_t>* shape);
+    return v;
+  }|]
+
+tensor_dim_unsafe
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_dim_unsafe _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).dim();
+  }|]
+
+tensor_dim_c_unsafe
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_dim_c_unsafe _obj =
+  [CUnsafe.block| int64_t { return (*$(at::Tensor* _obj)).dim();
+  }|]
diff --git a/src/Torch/Internal/Unmanaged/Type/Generator.hs b/src/Torch/Internal/Unmanaged/Type/Generator.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Generator.hs
@@ -0,0 +1,120 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Generator where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/detail/CUDAHooksInterface.h>"
+C.include "<ATen/CPUGeneratorImpl.h>"
+C.include "<ATen/core/Generator.h>"
+
+C.include "<vector>"
+
+
+newCUDAGenerator _device_index = getDefaultCUDAGenerator _device_index >>= generator_clone
+
+newCPUGenerator
+  :: Word64
+  -> IO (Ptr Generator)
+newCPUGenerator _seed_in =
+  [C.throwBlock| at::Generator* { return new at::Generator(at::detail::createCPUGenerator(
+    $(uint64_t _seed_in)));
+  }|]
+
+
+
+generator_set_current_seed
+  :: Ptr Generator
+  -> Word64
+  -> IO (())
+generator_set_current_seed _obj _seed =
+  [C.throwBlock| void {  (*$(at::Generator* _obj)).set_current_seed(
+    $(uint64_t _seed));
+  }|]
+
+generator_current_seed
+  :: Ptr Generator
+  -> IO (Word64)
+generator_current_seed _obj =
+  [C.throwBlock| uint64_t { return (*$(at::Generator* _obj)).current_seed(
+    );
+  }|]
+
+generator_seed
+  :: Ptr Generator
+  -> IO (Word64)
+generator_seed _obj =
+  [C.throwBlock| uint64_t { return (*$(at::Generator* _obj)).seed(
+    );
+  }|]
+
+generator_clone
+  :: Ptr Generator
+  -> IO (Ptr Generator)
+generator_clone _obj =
+  [C.throwBlock| at::Generator* { return new at::Generator((*$(at::Generator* _obj)).clone(
+    ));
+  }|]
+
+generator_get_device
+  :: Ptr Generator
+  -> IO Int64
+generator_get_device _obj =
+  [C.throwBlock| int64_t { return ((*$(at::Generator* _obj)).device().index());
+  }|]
+
+generator_is_cpu
+  :: Ptr Generator
+  -> IO CBool
+generator_is_cpu _obj =
+  [C.throwBlock| bool { return ((*$(at::Generator* _obj)).device().is_cpu());
+  }|]
+
+generator_is_cuda
+  :: Ptr Generator
+  -> IO CBool
+generator_is_cuda _obj =
+  [C.throwBlock| bool { return ((*$(at::Generator* _obj)).device().is_cuda());
+  }|]
+
+generator_is_hip
+  :: Ptr Generator
+  -> IO CBool
+generator_is_hip _obj =
+  [C.throwBlock| bool { return ((*$(at::Generator* _obj)).device().is_hip());
+  }|]
+
+getDefaultCUDAGenerator
+  :: Word16
+  -> IO (Ptr Generator)
+getDefaultCUDAGenerator _device_index =
+  [C.throwBlock| at::Generator* { return new at::Generator(at::detail::getCUDAHooks().getDefaultCUDAGenerator(
+    $(uint16_t _device_index)));
+  }|]
+
+getDefaultCPUGenerator
+  :: IO (Ptr Generator)
+getDefaultCPUGenerator  =
+  [C.throwBlock| at::Generator* { return new at::Generator(at::detail::getDefaultCPUGenerator(
+    ));
+  }|]
diff --git a/src/Torch/Internal/Unmanaged/Type/IValue.hs b/src/Torch/Internal/Unmanaged/Type/IValue.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/IValue.hs
@@ -0,0 +1,503 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
+
+module Torch.Internal.Unmanaged.Type.IValue where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/core/ivalue.h>"
+C.include "<vector>"
+
+class IValueLike a b where
+  toIValue :: a -> IO b
+  fromIValue :: b -> IO a
+
+instance IValueLike (Ptr IValue) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(at::IValue* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| at::IValue* { return new at::IValue((*$(at::IValue* _obj)).toIValue(
+      ));
+    }|]
+
+instance IValueLike (Ptr Tensor) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(at::Tensor* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::IValue* _obj)).toTensor(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10Ptr IVTuple)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::intrusive_ptr<at::ivalue::Tuple>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::intrusive_ptr<at::ivalue::Tuple>* { return new c10::intrusive_ptr<at::ivalue::Tuple>((*$(at::IValue* _obj)).toTuple(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10Dict '(IValue,IValue))) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::Dict<at::IValue,at::IValue>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::Dict<at::IValue,at::IValue>* { return new c10::Dict<at::IValue,at::IValue>((*$(at::IValue* _obj)).toGenericDict(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10List IValue)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::List<at::IValue>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::List<at::IValue>* { return new c10::List<at::IValue>((*$(at::IValue* _obj)).toList(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10List Tensor)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::List<at::Tensor>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::List<at::Tensor>* { return new c10::List<at::Tensor>((*$(at::IValue* _obj)).toTensorList(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10List CBool)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::List<bool>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::List<bool>* { return new c10::List<bool>((*$(at::IValue* _obj)).toBoolList(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10List Int64)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::List<int64_t>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::List<int64_t>* { return new c10::List<int64_t>((*$(at::IValue* _obj)).toIntList(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10List CDouble)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::List<double>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::List<double>* { return new c10::List<double>((*$(at::IValue* _obj)).toDoubleList(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10Ptr IVObject)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::intrusive_ptr<at::ivalue::Object>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::intrusive_ptr<at::ivalue::Object>* { return new c10::intrusive_ptr<at::ivalue::Object>((*$(at::IValue* _obj)).toObject(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10Ptr IVFuture)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::intrusive_ptr<at::ivalue::Future>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::intrusive_ptr<at::ivalue::Future>* { return new c10::intrusive_ptr<at::ivalue::Future>((*$(at::IValue* _obj)).toFuture(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10Ptr IVConstantString)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::intrusive_ptr<at::ivalue::ConstantString>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::intrusive_ptr<at::ivalue::ConstantString>* { return new c10::intrusive_ptr<at::ivalue::ConstantString>((*$(at::IValue* _obj)).toString(
+      ));
+    }|]
+
+instance IValueLike (Ptr StdString) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(std::string* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| std::string* { return new std::string((*$(at::IValue* _obj)).toStringRef(
+      ));
+    }|]
+
+instance IValueLike (Ptr Scalar) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(at::Scalar* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| at::Scalar* { return new at::Scalar((*$(at::IValue* _obj)).toScalar(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10Ptr Capsule)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::intrusive_ptr<torch::jit::CustomClassHolder>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::intrusive_ptr<torch::jit::CustomClassHolder>* { return new c10::intrusive_ptr<torch::jit::CustomClassHolder>((*$(at::IValue* _obj)).toCapsule(
+      ));
+    }|]
+
+instance IValueLike (Ptr (C10Ptr Blob)) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::intrusive_ptr<caffe2::Blob>* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::intrusive_ptr<caffe2::Blob>* { return new c10::intrusive_ptr<caffe2::Blob>((*$(at::IValue* _obj)).toBlob(
+      ));
+    }|]
+
+instance IValueLike CDouble (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      $(double _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| double { return ((*$(at::IValue* _obj)).toDouble(
+      ));
+    }|]
+
+instance IValueLike Int64 (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      $(int64_t _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| int64_t { return ((*$(at::IValue* _obj)).toInt(
+      ));
+    }|]
+
+instance IValueLike Int32 (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      $(int32_t _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| int32_t { return ((*$(at::IValue* _obj)).toInt(
+      ));
+    }|]
+
+instance IValueLike CBool (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      $(bool _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| bool { return ((*$(at::IValue* _obj)).toBool(
+      ));
+    }|]
+
+
+instance IValueLike (Ptr Device) (Ptr IValue) where
+  toIValue _x =
+    [C.throwBlock| at::IValue* { return new at::IValue(
+      *$(c10::Device* _x));
+    }|]
+  fromIValue _obj = 
+    [C.throwBlock| c10::Device* { return new c10::Device((*$(at::IValue* _obj)).toDevice(
+      ));
+    }|]
+
+newIValue
+  :: IO (Ptr IValue)
+newIValue  =
+  [C.throwBlock| at::IValue* { return new at::IValue() ; }|]
+
+
+iValue_isAliasOf_V
+  :: Ptr IValue
+  -> Ptr IValue
+  -> IO (CBool)
+iValue_isAliasOf_V _obj _rhs =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isAliasOf(
+    *$(at::IValue* _rhs));
+  }|]
+
+iValue_use_count
+  :: Ptr IValue
+  -> IO (CSize)
+iValue_use_count _obj =
+  [C.throwBlock| size_t { return (*$(at::IValue* _obj)).use_count(
+    );
+  }|]
+
+iValue_swap_V
+  :: Ptr IValue
+  -> Ptr IValue
+  -> IO (())
+iValue_swap_V _obj _rhs =
+  [C.throwBlock| void {  (*$(at::IValue* _obj)).swap(
+    *$(at::IValue* _rhs));
+  }|]
+
+iValue_isTensor
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isTensor _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isTensor(
+    );
+  }|]
+
+iValue_isBlob
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isBlob _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isBlob(
+    );
+  }|]
+
+iValue_isCapsule
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isCapsule _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isCapsule(
+    );
+  }|]
+
+iValue_isTuple
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isTuple _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isTuple(
+    );
+  }|]
+
+iValue_isDouble
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isDouble _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isDouble(
+    );
+  }|]
+
+iValue_isFuture
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isFuture _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isFuture(
+    );
+  }|]
+
+iValue_isInt
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isInt _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isInt(
+    );
+  }|]
+
+iValue_isIntList
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isIntList _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isIntList(
+    );
+  }|]
+
+iValue_isString
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isString _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isString(
+    );
+  }|]
+
+iValue_toStringRef
+  :: Ptr IValue
+  -> IO (Ptr StdString)
+iValue_toStringRef _obj =
+  [C.throwBlock| std::string* { return new std::string((*$(at::IValue* _obj)).toStringRef(
+    ));
+  }|]
+
+iValue_isDoubleList
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isDoubleList _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isDoubleList(
+    );
+  }|]
+
+iValue_isBool
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isBool _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isBool(
+    );
+  }|]
+
+iValue_isObject
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isObject _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isObject(
+    );
+  }|]
+
+iValue_isBoolList
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isBoolList _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isBoolList(
+    );
+  }|]
+
+iValue_isTensorList
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isTensorList _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isTensorList(
+    );
+  }|]
+
+iValue_isList
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isList _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isList(
+    );
+  }|]
+
+iValue_isGenericDict
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isGenericDict _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isGenericDict(
+    );
+  }|]
+
+iValue_isNone
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isNone _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isNone(
+    );
+  }|]
+
+iValue_toNone
+  :: Ptr IValue
+  -> IO (Ptr StdString)
+iValue_toNone _obj =
+  [C.throwBlock| std::string* { return new std::string((*$(at::IValue* _obj)).toNone(
+    ));
+  }|]
+
+iValue_isScalar
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isScalar _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isScalar(
+    );
+  }|]
+
+iValue_isDevice
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isDevice _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isDevice(
+    );
+  }|]
+
+iValue_toScalarType
+  :: Ptr IValue
+  -> IO (ScalarType)
+iValue_toScalarType _obj =
+  [C.throwBlock| at::ScalarType { return (*$(at::IValue* _obj)).toScalarType(
+    );
+  }|]
+
+iValue_toLayout
+  :: Ptr IValue
+  -> IO (Layout)
+iValue_toLayout _obj =
+  [C.throwBlock| at::Layout { return (*$(at::IValue* _obj)).toLayout(
+    );
+  }|]
+
+iValue_toMemoryFormat
+  :: Ptr IValue
+  -> IO (MemoryFormat)
+iValue_toMemoryFormat _obj =
+  [C.throwBlock| at::MemoryFormat { return (*$(at::IValue* _obj)).toMemoryFormat(
+    );
+  }|]
+
+iValue_toQScheme
+  :: Ptr IValue
+  -> IO (QScheme)
+iValue_toQScheme _obj =
+  [C.throwBlock| at::QScheme { return (*$(at::IValue* _obj)).toQScheme(
+    );
+  }|]
+
+iValue_tagKind
+  :: Ptr IValue
+  -> IO (Ptr StdString)
+iValue_tagKind _obj =
+  [C.throwBlock| std::string* { return new std::string((*$(at::IValue* _obj)).tagKind(
+    ));
+  }|]
+
+iValue_isSameIdentity_V
+  :: Ptr IValue
+  -> Ptr IValue
+  -> IO (CBool)
+iValue_isSameIdentity_V _obj _rhs =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isSameIdentity(
+    *$(at::IValue* _rhs));
+  }|]
+
+iValue_isPtrType
+  :: Ptr IValue
+  -> IO (CBool)
+iValue_isPtrType _obj =
+  [C.throwBlock| bool { return (*$(at::IValue* _obj)).isPtrType(
+    );
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/IValueList.hs b/src/Torch/Internal/Unmanaged/Type/IValueList.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/IValueList.hs
@@ -0,0 +1,77 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.IValueList where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/core/ivalue.h>"
+C.include "<vector>"
+
+
+
+newIValueList
+  :: IO (Ptr IValueList)
+newIValueList  =
+  [C.throwBlock| std::vector<at::IValue>* { return new std::vector<at::IValue>(
+    );
+  }|]
+
+
+
+
+ivalueList_empty
+  :: Ptr IValueList
+  -> IO (CBool)
+ivalueList_empty _obj =
+  [C.throwBlock| bool { return (*$(std::vector<at::IValue>* _obj)).empty(
+    );
+  }|]
+
+ivalueList_size
+  :: Ptr IValueList
+  -> IO (CSize)
+ivalueList_size _obj =
+  [C.throwBlock| size_t { return (*$(std::vector<at::IValue>* _obj)).size(
+    );
+  }|]
+
+ivalueList_at
+  :: Ptr IValueList
+  -> CSize
+  -> IO (Ptr IValue)
+ivalueList_at _obj _s =
+  [C.throwBlock| at::IValue* { return new at::IValue((*$(std::vector<at::IValue>* _obj)).at(
+    $(size_t _s)));
+  }|]
+
+ivalueList_push_back
+  :: Ptr IValueList
+  -> Ptr IValue
+  -> IO (())
+ivalueList_push_back _obj _v =
+  [C.throwBlock| void {  (*$(std::vector<at::IValue>* _obj)).push_back(
+    *$(at::IValue* _v));
+  }|]
+
+
+
diff --git a/src/Torch/Internal/Unmanaged/Type/IntArray.hs b/src/Torch/Internal/Unmanaged/Type/IntArray.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/IntArray.hs
@@ -0,0 +1,96 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.IntArray where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Language.C.Inline.Unsafe as CUnsafe
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Foreign.Marshal.Array
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/ScalarType.h>"
+C.include "<vector>"
+
+
+
+newIntArray
+  :: IO (Ptr IntArray)
+newIntArray  =
+  [C.throwBlock| std::vector<int64_t>* { return new std::vector<int64_t>(
+    );
+  }|]
+
+intArray_empty
+  :: Ptr IntArray
+  -> IO (CBool)
+intArray_empty _obj =
+  [CUnsafe.block| bool { return (*$(std::vector<int64_t>* _obj)).empty(
+    );
+  }|]
+
+intArray_size
+  :: Ptr IntArray
+  -> IO (CSize)
+intArray_size _obj =
+  [CUnsafe.block| size_t { return (*$(std::vector<int64_t>* _obj)).size(
+    );
+  }|]
+
+intArray_at_s
+  :: Ptr IntArray
+  -> CSize
+  -> IO (Int64)
+intArray_at_s _obj _s =
+  [CUnsafe.block| int64_t { return (*$(std::vector<int64_t>* _obj)).at(
+    $(size_t _s));
+  }|]
+
+intArray_push_back_l
+  :: Ptr IntArray
+  -> Int64
+  -> IO (())
+intArray_push_back_l _obj _v =
+  [C.throwBlock| void {  (*$(std::vector<int64_t>* _obj)).push_back(
+    $(int64_t _v));
+  }|]
+
+intArray_fromList
+  :: Ptr IntArray
+  -> [Int64]
+  -> IO (())
+intArray_fromList _obj _v = do
+  let size = fromIntegral $ length _v
+  ptr <- [C.throwBlock| int64_t* {
+    (*$(std::vector<int64_t>* _obj)).resize($(int size));
+    return (int64_t*)((*$(std::vector<int64_t>* _obj)).data());
+  }|]
+  pokeArray (ptr :: Ptr Int64)  _v
+
+intArray_toList
+  :: Ptr IntArray
+  -> IO [Int64]
+intArray_toList _obj = do
+  size <- intArray_size _obj
+  ptr <- [CUnsafe.block| int64_t* {
+    return (int64_t*)((*$(std::vector<int64_t>* _obj)).data());
+  }|]
+  peekArray (fromIntegral size) (ptr :: Ptr Int64)
diff --git a/src/Torch/Internal/Unmanaged/Type/Module.hs b/src/Torch/Internal/Unmanaged/Type/Module.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Module.hs
@@ -0,0 +1,488 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeFamilies #-}
+
+module Torch.Internal.Unmanaged.Type.Module where
+
+import Control.Exception.Safe (bracket)
+import Data.IORef
+import qualified Data.Map as Map
+import Foreign
+import Foreign.C.String
+import Foreign.C.Types
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Cpp.Exceptions as Safe
+import qualified Language.C.Types as C
+import Torch.Internal.Type
+import Torch.Internal.Unmanaged.Helper
+import Control.Exception.Safe (bracket)
+import Control.Monad (forM)
+
+C.context $ C.cppCtx <> mempty {C.ctxTypesTable = typeTable}
+
+C.include "hasktorch_profile.h"
+
+C.include "<torch/script.h>"
+
+C.include "<torch/csrc/jit/serialization/export.h>"
+
+C.include "<torch/csrc/jit/frontend/tracer.h>"
+
+C.include "<vector>"
+
+C.include "<iostream>"
+
+-- From libtorch/include/torch/csrc/jit/script/module.h
+
+newModule ::
+  Ptr StdString -> IO (Ptr Module)
+newModule name =
+  [C.throwBlock| torch::jit::script::Module* { return new torch::jit::script::Module(
+     *$(std::string* name)
+    );
+  }|]
+
+save :: Ptr Module -> FilePath -> IO ()
+save obj file = withCString file $ \cfile ->
+  [C.throwBlock| void {
+    $(torch::jit::script::Module* obj)->save($(char* cfile));
+  }|]
+
+load :: FilePath -> IO (Ptr Module)
+load file = withCString file $ \cfile ->
+  [C.throwBlock| torch::jit::script::Module* {
+    return new torch::jit::script::Module(torch::jit::load($(char* cfile)));
+  }|]
+
+forward :: Ptr Module -> Ptr (StdVector IValue) -> IO (Ptr IValue)
+forward obj inputs =
+  [C.throwBlock| at::IValue* {
+    return new at::IValue($(torch::jit::script::Module* obj)->forward(*$(std::vector<at::IValue>* inputs)));
+  }|]
+
+registerParameter :: Ptr Module -> Ptr StdString -> Ptr Tensor -> CBool -> IO ()
+registerParameter obj name v is_buffer =
+  [C.throwBlock| void {
+    $(torch::jit::script::Module* obj)->register_parameter(
+      *$(std::string* name)
+    , *$(at::Tensor* v)
+    , $(bool is_buffer)
+    );
+  }|]
+
+registerModule :: Ptr Module -> Ptr StdString -> Ptr Module -> IO ()
+registerModule obj name v =
+  [C.throwBlock| void {
+    $(torch::jit::script::Module* obj)->register_module(
+      *$(std::string* name)
+    , *$(torch::jit::script::Module* v)
+    );
+  }|]
+
+train :: Ptr Module -> CBool -> IO ()
+train obj on =
+  [C.throwBlock| void {
+    $(torch::jit::script::Module* obj)->train(
+      $(bool on)
+    );
+  }|]
+
+runMethod :: Ptr Module -> Ptr StdString -> Ptr (C10List IValue) -> IO (Ptr IValue)
+runMethod obj method_name args =
+  [C.throwBlock| at::IValue* {
+    return new at::IValue($(torch::jit::script::Module* obj)->run_method(
+      *$(std::string* method_name)
+    , *$(c10::List<at::IValue>* args)
+    ));
+  }|]
+
+runMethod1 :: Ptr Module -> Ptr StdString -> Ptr IValue -> IO (Ptr IValue)
+runMethod1 obj method_name args =
+  [C.throwBlock| at::IValue* {
+    return new at::IValue($(torch::jit::script::Module* obj)->run_method(
+      *$(std::string* method_name)
+    , *$(at::IValue* args)
+    ));
+  }|]
+
+getParameters :: Ptr Module -> IO (Ptr TensorList)
+getParameters obj =
+  [C.throwBlock| std::vector<at::Tensor>* {
+    std::vector<at::Tensor>* vec_parameters = new std::vector<at::Tensor>();
+    auto parameters = $(torch::jit::script::Module* obj)->parameters();
+    for(auto p : parameters) {
+      vec_parameters->push_back(p);
+    }
+    return vec_parameters;
+  }|]
+
+setParameters :: Ptr Module -> Ptr TensorList -> IO ()
+setParameters obj params =
+  [C.throwBlock| void {
+    auto module = $(torch::jit::script::Module* obj);
+    auto parameters = module->named_parameters();
+    auto vec = $(std::vector<at::Tensor>* params);
+    int i=0; 
+    for(auto p : parameters) {
+      module->register_parameter(p.name,(*vec)[i],false);
+    }
+  }|]
+
+getNamedParameters :: Ptr Module -> IO [(Ptr StdString,Ptr Tensor)]
+getNamedParameters _obj = do
+  let new = [C.throwBlock| std::vector<std::tuple<std::string,at::Tensor>>* {
+              auto module = $(torch::jit::script::Module* _obj);
+              auto obj = module->named_parameters();
+              auto ret = new std::vector<std::tuple<std::string,at::Tensor>>();
+              for(auto p : obj){
+                ret->push_back({p.name,p.value});
+              }
+              return ret;
+             }|]
+      free dat = [C.throwBlock| void {
+              delete $(std::vector<std::tuple<std::string,at::Tensor>>* dat);
+             }|]
+  bracket new free $ \dat -> do
+    size <- [C.throwBlock| int64_t { return (long int)$(std::vector<std::tuple<std::string,at::Tensor>>* dat)->size();}|]
+    ret <- forM [0..(size-1)] $ \i -> do
+      key <- [C.throwBlock| std::string* { return new std::string(std::get<0>($(std::vector<std::tuple<std::string,at::Tensor>>* dat)->at($(int64_t i))));}|]
+      val <- [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>($(std::vector<std::tuple<std::string,at::Tensor>>* dat)->at($(int64_t i))));}|]
+      return (key,val)
+    return ret
+
+getNamedBuffers :: Ptr Module -> IO [(Ptr StdString,Ptr Tensor)]
+getNamedBuffers _obj = do
+  let new = [C.throwBlock| std::vector<std::tuple<std::string,at::Tensor>>* {
+              auto module = $(torch::jit::script::Module* _obj);
+              auto obj = module->named_buffers();
+              auto ret = new std::vector<std::tuple<std::string,at::Tensor>>();
+              for(auto p : obj){
+                ret->push_back({p.name,p.value});
+              }
+              return ret;
+             }|]
+      free dat = [C.throwBlock| void {
+              delete $(std::vector<std::tuple<std::string,at::Tensor>>* dat);
+             }|]
+  bracket new free $ \dat -> do
+    size <- [C.throwBlock| int64_t { return (long int)$(std::vector<std::tuple<std::string,at::Tensor>>* dat)->size();}|]
+    ret <- forM [0..(size-1)] $ \i -> do
+      key <- [C.throwBlock| std::string* { return new std::string(std::get<0>($(std::vector<std::tuple<std::string,at::Tensor>>* dat)->at($(int64_t i))));}|]
+      val <- [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>($(std::vector<std::tuple<std::string,at::Tensor>>* dat)->at($(int64_t i))));}|]
+      return (key,val)
+    return ret
+
+getNamedAttributes :: Ptr Module -> IO [(Ptr StdString,Ptr IValue)]
+getNamedAttributes _obj = do
+  let new = [C.throwBlock| std::vector<std::tuple<std::string,at::IValue>>* {
+              auto module = $(torch::jit::script::Module* _obj);
+              auto obj = module->named_attributes();
+              auto ret = new std::vector<std::tuple<std::string,at::IValue>>();
+              for(auto p : obj){
+                ret->push_back({p.name,p.value});
+              }
+              return ret;
+             }|]
+      free dat = [C.throwBlock| void {
+              delete $(std::vector<std::tuple<std::string,at::IValue>>* dat);
+             }|]
+  bracket new free $ \dat -> do
+    size <- [C.throwBlock| int64_t { return (long int)$(std::vector<std::tuple<std::string,at::IValue>>* dat)->size();}|]
+    ret <- forM [0..(size-1)] $ \i -> do
+      key <- [C.throwBlock| std::string* { return new std::string(std::get<0>($(std::vector<std::tuple<std::string,at::IValue>>* dat)->at($(int64_t i))));}|]
+      val <- [C.throwBlock| at::IValue* { return new at::IValue(std::get<1>($(std::vector<std::tuple<std::string,at::IValue>>* dat)->at($(int64_t i))));}|]
+      return (key,val)
+    return ret
+
+getNamedModules :: Ptr Module -> IO [(Ptr StdString,Ptr Module)]
+getNamedModules _obj = do
+  let new = [C.throwBlock| std::vector<std::tuple<std::string,torch::jit::script::Module>>* {
+              auto module = $(torch::jit::script::Module* _obj);
+              auto obj = module->named_modules();
+              auto ret = new std::vector<std::tuple<std::string,torch::jit::script::Module>>();
+              for(auto p : obj){
+                ret->push_back({p.name,p.value});
+              }
+              return ret;
+             }|]
+      free dat = [C.throwBlock| void {
+              delete $(std::vector<std::tuple<std::string,torch::jit::script::Module>>* dat);
+             }|]
+  bracket new free $ \dat -> do
+    size <- [C.throwBlock| int64_t { return (long int)$(std::vector<std::tuple<std::string,torch::jit::script::Module>>* dat)->size();}|]
+    ret <- forM [0..(size-1)] $ \i -> do
+      key <- [C.throwBlock| std::string* { return new std::string(std::get<0>($(std::vector<std::tuple<std::string,torch::jit::script::Module>>* dat)->at($(int64_t i))));}|]
+      val <- [C.throwBlock| torch::jit::script::Module* { return new torch::jit::script::Module(std::get<1>($(std::vector<std::tuple<std::string,torch::jit::script::Module>>* dat)->at($(int64_t i))));}|]
+      return (key,val)
+    return ret
+
+getNamedChildren :: Ptr Module -> IO [(Ptr StdString,Ptr Module)]
+getNamedChildren _obj = do
+  let new = [C.throwBlock| std::vector<std::tuple<std::string,torch::jit::script::Module>>* {
+              auto module = $(torch::jit::script::Module* _obj);
+              auto obj = module->named_children();
+              auto ret = new std::vector<std::tuple<std::string,torch::jit::script::Module>>();
+              for(auto p : obj){
+                ret->push_back({p.name,p.value});
+              }
+              return ret;
+             }|]
+      free dat = [C.throwBlock| void {
+              delete $(std::vector<std::tuple<std::string,torch::jit::script::Module>>* dat);
+             }|]
+  bracket new free $ \dat -> do
+    size <- [C.throwBlock| int64_t { return (long int)$(std::vector<std::tuple<std::string,torch::jit::script::Module>>* dat)->size();}|]
+    ret <- forM [0..(size-1)] $ \i -> do
+      key <- [C.throwBlock| std::string* { return new std::string(std::get<0>($(std::vector<std::tuple<std::string,torch::jit::script::Module>>* dat)->at($(int64_t i))));}|]
+      val <- [C.throwBlock| torch::jit::script::Module* { return new torch::jit::script::Module(std::get<1>($(std::vector<std::tuple<std::string,torch::jit::script::Module>>* dat)->at($(int64_t i))));}|]
+      return (key,val)
+    return ret
+
+
+toDevice :: Ptr Module -> DeviceType -> Int16 -> IO ()
+toDevice obj device device_index =
+  [C.throwBlock| void {
+    $(torch::jit::script::Module* obj)->to(torch::Device($(at::DeviceType device), $(int16_t device_index)));
+  }|]
+
+clone :: Ptr Module -> IO (Ptr Module)
+clone obj =
+  [C.throwBlock| torch::jit::script::Module* {
+    return new torch::jit::script::Module($(torch::jit::script::Module* obj)->clone());
+  }|]
+
+define :: Ptr Module -> Ptr StdString -> IO ()
+define obj src =
+  [C.throwBlock| void {
+    $(torch::jit::script::Module* obj)->define(
+      *$(std::string* src)
+    );
+  }|]
+
+trace :: CString -> CString -> (Ptr TensorList -> IO (Ptr TensorList)) -> Ptr TensorList -> IO (Ptr Module)
+trace moduleName functionName func inputs =
+  bracket
+    (callbackHelper $ \inputs' -> castPtr <$> func (castPtr inputs'))
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [Safe.throwBlock| torch::jit::script::Module* {
+        torch::jit::script::Module self($(char* moduleName));
+        auto vars_in = *$(std::vector<at::Tensor>* inputs);
+        auto tfunc = $(void* (*funcPtr)(void*));
+        typedef std::vector<at::Tensor>* (*Func)(std::vector<at::Tensor>*);
+        auto func = (Func)tfunc;
+        auto graph = torch::jit::tracer::trace(
+          c10::fmap<c10::IValue>(vars_in),
+          [&func](c10::Stack in) -> c10::Stack {
+            std::vector<at::Tensor>* ivalue_inps = new std::vector<at::Tensor>(c10::fmap(in, [](const c10::IValue& v){
+              return torch::autograd::Variable(v.toTensor());
+            }));
+            std::vector<at::Tensor> out = *(func(ivalue_inps));
+            return c10::fmap<c10::IValue>(out);
+          },
+          [](const torch::autograd::Variable& var) { return "";}
+        ).first->graph;
+        auto v = graph->insertInput(0, "self");
+        v->setType(self._ivalue()->type());
+        const auto name = c10::QualifiedName(*self.type()->name(), $(char* functionName));
+        auto fn2 = self._ivalue()->compilation_unit()->create_function(name,graph);
+        self.type()->addMethod(fn2);
+        return new torch::jit::script::Module(self);
+      }|]
+
+traceAsGraph :: (Ptr TensorList -> IO (Ptr TensorList)) -> Ptr TensorList -> IO (Ptr (SharedPtr JitGraph))
+traceAsGraph func inputs =
+  bracket
+    (callbackHelper $ \inputs' -> castPtr <$> func (castPtr inputs'))
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [Safe.throwBlock| std::shared_ptr<torch::jit::Graph>* {
+        torch::jit::script::Module self("MyModule");
+        auto vars_in = *$(std::vector<at::Tensor>* inputs);
+        auto tfunc = $(void* (*funcPtr)(void*));
+        typedef std::vector<at::Tensor>* (*Func)(std::vector<at::Tensor>*);
+        auto func = (Func)tfunc;
+        auto graph = torch::jit::tracer::trace(
+          c10::fmap<c10::IValue>(vars_in),
+          [&func](c10::Stack in) -> c10::Stack {
+            std::vector<at::Tensor>* ivalue_inps = new std::vector<at::Tensor>(c10::fmap(in, [](const c10::IValue& v){
+              return torch::autograd::Variable(v.toTensor());
+            }));
+            std::vector<at::Tensor> out = *(func(ivalue_inps));
+            return c10::fmap<c10::IValue>(out);
+          },
+          [](const torch::autograd::Variable& var) { return "";}
+        ).first->graph;
+        return new std::shared_ptr<torch::jit::Graph>(graph);
+      }|]
+
+withJitGraph :: Ptr (SharedPtr JitGraph) -> (Ptr JitGraph -> IO a) -> IO a
+withJitGraph graph callback = do
+  v <-
+    [C.throwBlock| torch::jit::Graph* {
+         return (*$(std::shared_ptr<torch::jit::Graph>* graph)).get();
+       }|]
+  callback v
+
+graphOutputs :: Ptr JitGraph -> IO [Ptr JitValue]
+graphOutputs graph = do
+  nodes <- newIORef []
+  let func v = do
+        r <- readIORef nodes -- TODO: Combine with -:242:9 & -:263:9
+        writeIORef nodes (v : r)
+        return v
+  bracket
+    (callbackHelper $ \inputs' -> castPtr <$> func (castPtr inputs'))
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [Safe.throwBlock| void {
+        auto tfunc = $(void* (*funcPtr)(void*));
+        typedef torch::jit::Value* (*Func)(torch::jit::Value*);
+        auto func = (Func)tfunc;
+        for(auto i : (*$(torch::jit::Graph* graph)).outputs()){
+          func(i);
+        }
+      }|]
+  reverse <$> readIORef nodes
+
+graphInputs :: Ptr JitGraph -> IO [Ptr JitValue]
+graphInputs graph = do
+  nodes <- newIORef []
+  let func v = do
+        r <- readIORef nodes
+        writeIORef nodes (v : r)
+        return v
+  bracket
+    (callbackHelper $ \inputs' -> castPtr <$> func (castPtr inputs'))
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [Safe.throwBlock| void {
+        auto tfunc = $(void* (*funcPtr)(void*));
+        typedef torch::jit::Value* (*Func)(torch::jit::Value*);
+        auto func = (Func)tfunc;
+        for(auto i : (*$(torch::jit::Graph* graph)).inputs()){
+          func(i);
+        }
+      }|]
+  reverse <$> readIORef nodes
+
+graphNodes :: Ptr JitGraph -> IO [Ptr JitNode]
+graphNodes graph = do
+  nodes <- newIORef []
+  let func v = do
+        r <- readIORef nodes
+        writeIORef nodes (v : r)
+        return v
+  bracket
+    (callbackHelper $ \inputs' -> castPtr <$> func (castPtr inputs'))
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [Safe.throwBlock| void {
+        auto tfunc = $(void* (*funcPtr)(void*));
+        typedef torch::jit::Node* (*Func)(torch::jit::Node*);
+        auto func = (Func)tfunc;
+        for(auto i : (*$(torch::jit::Graph* graph)).block()->nodes()){
+          func(i);
+        }
+      }|]
+  reverse <$> readIORef nodes
+
+nodeInputs :: Ptr JitNode -> IO [Ptr JitValue]
+nodeInputs node = do
+  values <- newIORef []
+  let func v = do
+        r <- readIORef values -- TODO: Combine with -:305:9
+        writeIORef values (v : r)
+        return v
+  bracket
+    (callbackHelper $ \inputs' -> castPtr <$> func (castPtr inputs'))
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [Safe.throwBlock| void {
+        auto tfunc = $(void* (*funcPtr)(void*));
+        typedef torch::jit::Value* (*Func)(torch::jit::Value*);
+        auto func = (Func)tfunc;
+        for(auto i : (*$(torch::jit::Node* node)).inputs()){
+          func(i);
+        }
+      }|]
+  reverse <$> readIORef values
+
+nodeOutputs :: Ptr JitNode -> IO [Ptr JitValue]
+nodeOutputs node = do
+  values <- newIORef []
+  let func v = do
+        r <- readIORef values
+        writeIORef values (v : r)
+        return v
+  bracket
+    (callbackHelper $ \inputs' -> castPtr <$> func (castPtr inputs'))
+    freeHaskellFunPtr
+    $ \funcPtr ->
+      [Safe.throwBlock| void {
+        auto tfunc = $(void* (*funcPtr)(void*));
+        typedef torch::jit::Value* (*Func)(torch::jit::Value*);
+        auto func = (Func)tfunc;
+        for(auto i : (*$(torch::jit::Node* node)).outputs()){
+          func(i);
+        }
+      }|]
+  reverse <$> readIORef values
+
+nodeKind :: Ptr JitNode -> IO (Ptr StdString)
+nodeKind node =
+  [C.throwBlock| std::string* {
+    return new std::string((*$(torch::jit::Node* node)).kind().toQualString());
+  }|]
+
+valueId :: Ptr JitValue -> IO CInt
+valueId value =
+  [C.throwBlock| int {
+    return (*$(torch::jit::Value* value)).unique();
+  }|]
+
+valueType :: Ptr JitValue -> IO (Ptr StdString)
+valueType node =
+  [C.throwBlock| std::string* {
+    return new std::string((*$(torch::jit::Value* node)).type()->str());
+  }|]
+
+printGraph :: Ptr (SharedPtr JitGraph) -> IO (Ptr StdString)
+printGraph graph =
+  [C.throwBlock| std::string* {
+    return new std::string((**$(std::shared_ptr<torch::jit::Graph>* graph)).toString());
+  }|]
+
+printOnnx :: Ptr (SharedPtr JitGraph) -> IO (Ptr StdString)
+printOnnx graph =
+  [C.throwBlock| std::string* {
+    auto graph_str = torch::jit::pretty_print_onnx(
+        *$(std::shared_ptr<torch::jit::Graph>* graph),
+        std::map<std::string, at::Tensor>{},
+        9,
+        false);
+    return new std::string(graph_str);
+  }|]
+
+dumpToStr ::
+  Ptr Module ->
+  CBool ->
+  CBool ->
+  CBool ->
+  IO (Ptr StdString)
+dumpToStr obj print_method_bodies print_attr_values print_param_values =
+  [C.throwBlock| std::string* {
+    return new std::string($(torch::jit::script::Module* obj)->dump_to_str(
+      $(bool print_method_bodies)
+    , $(bool print_attr_values)
+    , $(bool print_param_values)
+    ));
+  }|]
diff --git a/src/Torch/Internal/Unmanaged/Type/Scalar.hs b/src/Torch/Internal/Unmanaged/Type/Scalar.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Scalar.hs
@@ -0,0 +1,70 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Scalar where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/Scalar.h>"
+C.include "<vector>"
+
+
+
+newScalar
+  :: IO (Ptr Scalar)
+newScalar  =
+  [C.throwBlock| at::Scalar* { return new at::Scalar(
+    );
+  }|]
+
+newScalar_i
+  :: CInt
+  -> IO (Ptr Scalar)
+newScalar_i _a =
+  [C.throwBlock| at::Scalar* { return new at::Scalar(
+    $(int _a));
+  }|]
+
+newScalar_d
+  :: CDouble
+  -> IO (Ptr Scalar)
+newScalar_d _a =
+  [C.throwBlock| at::Scalar* { return new at::Scalar(
+    $(double _a));
+  }|]
+
+newScalar_b
+  :: CBool
+  -> IO (Ptr Scalar)
+newScalar_b _a =
+  [C.throwBlock| at::Scalar* { return new at::Scalar(
+    $(bool _a));
+  }|]
+
+newScalar_f
+  :: CFloat
+  -> IO (Ptr Scalar)
+newScalar_f _a =
+  [C.throwBlock| at::Scalar* { return new at::Scalar(
+    $(float _a));
+  }|]
diff --git a/src/Torch/Internal/Unmanaged/Type/StdArray.hs b/src/Torch/Internal/Unmanaged/Type/StdArray.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/StdArray.hs
@@ -0,0 +1,108 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.StdArray where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<array>"
+
+
+
+newStdArrayBool2
+  :: IO (Ptr (StdArray '(CBool,2)))
+newStdArrayBool2  =
+  [C.throwBlock| std::array<bool,2>* { return new std::array<bool,2>(
+    );
+  }|]
+
+newStdArrayBool2_bb
+  :: CBool
+  -> CBool
+  -> IO (Ptr (StdArray '(CBool,2)))
+newStdArrayBool2_bb b0 b1 =
+  [C.throwBlock| std::array<bool,2>* { return new std::array<bool,2>({$(bool b0),$(bool b1)}); }|]
+
+instance CppTuple2 (Ptr (StdArray '(CBool,2))) where
+  type A (Ptr (StdArray '(CBool,2))) = CBool
+  type B (Ptr (StdArray '(CBool,2))) = CBool
+  get0 v = [C.throwBlock| bool { return std::get<0>(*$(std::array<bool,2>* v));}|]
+  get1 v = [C.throwBlock| bool { return std::get<1>(*$(std::array<bool,2>* v));}|]
+
+newStdArrayBool3
+  :: IO (Ptr (StdArray '(CBool,3)))
+newStdArrayBool3  =
+  [C.throwBlock| std::array<bool,3>* { return new std::array<bool,3>(
+    );
+  }|]
+
+newStdArrayBool3_bbb
+  :: CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdArray '(CBool,3)))
+newStdArrayBool3_bbb b0 b1 b2 =
+  [C.throwBlock| std::array<bool,3>* { return new std::array<bool,3>({$(bool b0),$(bool b1),$(bool b2)}); }|]
+
+instance CppTuple2 (Ptr (StdArray '(CBool,3))) where
+  type A (Ptr (StdArray '(CBool,3))) = CBool
+  type B (Ptr (StdArray '(CBool,3))) = CBool
+  get0 v = [C.throwBlock| bool { return std::get<0>(*$(std::array<bool,3>* v));}|]
+  get1 v = [C.throwBlock| bool { return std::get<1>(*$(std::array<bool,3>* v));}|]
+
+instance CppTuple3 (Ptr (StdArray '(CBool,3))) where
+  type C (Ptr (StdArray '(CBool,3))) = CBool
+  get2 v = [C.throwBlock| bool { return std::get<2>(*$(std::array<bool,3>* v));}|]
+
+newStdArrayBool4
+  :: IO (Ptr (StdArray '(CBool,4)))
+newStdArrayBool4  =
+  [C.throwBlock| std::array<bool,4>* { return new std::array<bool,4>(
+    );
+  }|]
+
+newStdArrayBool4_bbbb
+  :: CBool
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdArray '(CBool,4)))
+newStdArrayBool4_bbbb b0 b1 b2 b3 =
+  [C.throwBlock| std::array<bool,4>* { return new std::array<bool,4>({$(bool b0),$(bool b1),$(bool b2),$(bool b3)}); }|]
+
+instance CppTuple2 (Ptr (StdArray '(CBool,4))) where
+  type A (Ptr (StdArray '(CBool,4))) = CBool
+  type B (Ptr (StdArray '(CBool,4))) = CBool
+  get0 v = [C.throwBlock| bool { return std::get<0>(*$(std::array<bool,4>* v));}|]
+  get1 v = [C.throwBlock| bool { return std::get<1>(*$(std::array<bool,4>* v));}|]
+
+instance CppTuple3 (Ptr (StdArray '(CBool,4))) where
+  type C (Ptr (StdArray '(CBool,4))) = CBool
+  get2 v = [C.throwBlock| bool { return std::get<2>(*$(std::array<bool,4>* v));}|]
+
+instance CppTuple4 (Ptr (StdArray '(CBool,4))) where
+  type D (Ptr (StdArray '(CBool,4))) = CBool
+  get3 v = [C.throwBlock| bool { return std::get<3>(*$(std::array<bool,4>* v));}|]
+
+
+
diff --git a/src/Torch/Internal/Unmanaged/Type/StdString.hs b/src/Torch/Internal/Unmanaged/Type/StdString.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/StdString.hs
@@ -0,0 +1,47 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.StdString where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<string>"
+
+
+
+newStdString
+  :: IO (Ptr StdString)
+newStdString  =
+  [C.throwBlock| std::string* { return new std::string(
+    );
+  }|]
+
+newStdString_s
+  :: String
+  -> IO (Ptr StdString)
+newStdString_s str =
+  withCString str $ \cstr -> [C.throwBlock| std::string* { return new std::string($(char* cstr));}|]
+
+string_c_str
+  :: Ptr StdString
+  -> IO String
+string_c_str str = [C.throwBlock| const char* { return (*$(std::string* str)).c_str();}|] >>= peekCString
diff --git a/src/Torch/Internal/Unmanaged/Type/StdVector.hs b/src/Torch/Internal/Unmanaged/Type/StdVector.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/StdVector.hs
@@ -0,0 +1,87 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.StdVector where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/Scalar.h>"
+C.include "<vector>"
+
+newStdVectorScalar :: IO (Ptr (StdVector Scalar))
+newStdVectorScalar = [C.throwBlock| std::vector<at::Scalar>* { return new std::vector<at::Scalar>(); }|]
+
+newStdVectorDouble :: IO (Ptr (StdVector CDouble))
+newStdVectorDouble = [C.throwBlock| std::vector<double>* { return new std::vector<double>(); }|]
+
+newStdVectorInt :: IO (Ptr (StdVector Int64))
+newStdVectorInt = [C.throwBlock| std::vector<int64_t>* { return new std::vector<int64_t>(); }|]
+
+newStdVectorBool :: IO (Ptr (StdVector CBool))
+newStdVectorBool = [C.throwBlock| std::vector<bool>* { return new std::vector<bool>(); }|]
+
+stdVectorScalar_empty :: Ptr (StdVector Scalar) -> IO (CBool)
+stdVectorScalar_empty _obj = [C.throwBlock| bool { return (*$(std::vector<at::Scalar>* _obj)).empty(); }|]
+
+stdVectorDouble_empty :: Ptr (StdVector CDouble) -> IO (CBool)
+stdVectorDouble_empty _obj = [C.throwBlock| bool { return (*$(std::vector<double>* _obj)).empty(); }|]
+
+stdVectorInt_empty :: Ptr (StdVector Int64) -> IO (CBool)
+stdVectorInt_empty _obj = [C.throwBlock| bool { return (*$(std::vector<int64_t>* _obj)).empty(); }|]
+
+stdVectorBool_empty :: Ptr (StdVector CBool) -> IO (CBool)
+stdVectorBool_empty _obj = [C.throwBlock| bool { return (*$(std::vector<bool>* _obj)).empty(); }|]
+
+stdVectorDouble_size :: Ptr (StdVector CDouble) -> IO (CSize)
+stdVectorDouble_size _obj = [C.throwBlock| size_t { return (*$(std::vector<double>* _obj)).size(); }|]
+
+stdVectorInt_size :: Ptr (StdVector Int64) -> IO (CSize)
+stdVectorInt_size _obj = [C.throwBlock| size_t { return (*$(std::vector<int64_t>* _obj)).size(); }|]
+
+stdVectorBool_size :: Ptr (StdVector CBool) -> IO (CSize)
+stdVectorBool_size _obj = [C.throwBlock| size_t { return (*$(std::vector<bool>* _obj)).size(); }|]
+
+stdVectorScalar_at :: Ptr (StdVector Scalar) -> CSize -> IO (Ptr Scalar)
+stdVectorScalar_at _obj _s = [C.throwBlock| at::Scalar* { return new at::Scalar((*$(std::vector<at::Scalar>* _obj))[$(size_t _s)]); }|]
+
+stdVectorDouble_at :: Ptr (StdVector CDouble) -> CSize -> IO CDouble
+stdVectorDouble_at _obj _s = [C.throwBlock| double { return (double)((*$(std::vector<double>* _obj))[$(size_t _s)]); }|]
+
+stdVectorInt_at :: Ptr (StdVector Int64) -> CSize -> IO Int64
+stdVectorInt_at _obj _s = [C.throwBlock| int64_t { return (int64_t)((*$(std::vector<int64_t>* _obj))[$(size_t _s)]); }|]
+
+stdVectorBool_at :: Ptr (StdVector CBool) -> CSize -> IO CBool
+stdVectorBool_at _obj _s = [C.throwBlock| bool { return ((*$(std::vector<bool>* _obj))[$(size_t _s)]); }|]
+
+stdVectorScalar_push_back :: Ptr (StdVector Scalar) -> Ptr Scalar -> IO ()
+stdVectorScalar_push_back _obj _v = [C.throwBlock| void {  (*$(std::vector<at::Scalar>* _obj)).push_back(*$(at::Scalar* _v)); }|]
+
+stdVectorDouble_push_back :: Ptr (StdVector CDouble) -> CDouble -> IO ()
+stdVectorDouble_push_back _obj _v = [C.throwBlock| void {  (*$(std::vector<double>* _obj)).push_back($(double _v)); }|]
+
+stdVectorInt_push_back :: Ptr (StdVector Int64) -> Int64 -> IO ()
+stdVectorInt_push_back _obj _v = [C.throwBlock| void {  (*$(std::vector<int64_t>* _obj)).push_back($(int64_t _v)); }|]
+
+stdVectorBool_push_back :: Ptr (StdVector CBool) -> CBool -> IO ()
+stdVectorBool_push_back _obj _v = [C.throwBlock| void {  (*$(std::vector<bool>* _obj)).push_back($(bool _v)); }|]
+
+
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Storage.hs b/src/Torch/Internal/Unmanaged/Type/Storage.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Storage.hs
@@ -0,0 +1,39 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Storage where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/Storage.h>"
+C.include "<vector>"
+
+
+
+newStorage
+  :: IO (Ptr Storage)
+newStorage  =
+  [C.throwBlock| at::Storage* { return new at::Storage(
+    );
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Symbol.hs b/src/Torch/Internal/Unmanaged/Type/Symbol.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Symbol.hs
@@ -0,0 +1,174 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Symbol where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/core/interned_strings.h>"
+
+
+
+newSymbol
+  :: IO (Ptr Symbol)
+newSymbol  =
+  [C.throwBlock| at::Symbol* { return new at::Symbol(
+    );
+  }|]
+
+symbol_is_attr
+  :: Ptr Symbol
+  -> IO (CBool)
+symbol_is_attr _obj =
+  [C.throwBlock| bool { return (*$(at::Symbol* _obj)).is_attr(
+    );
+  }|]
+
+symbol_is_aten
+  :: Ptr Symbol
+  -> IO (CBool)
+symbol_is_aten _obj =
+  [C.throwBlock| bool { return (*$(at::Symbol* _obj)).is_aten(
+    );
+  }|]
+
+symbol_is_prim
+  :: Ptr Symbol
+  -> IO (CBool)
+symbol_is_prim _obj =
+  [C.throwBlock| bool { return (*$(at::Symbol* _obj)).is_prim(
+    );
+  }|]
+
+symbol_is_onnx
+  :: Ptr Symbol
+  -> IO (CBool)
+symbol_is_onnx _obj =
+  [C.throwBlock| bool { return (*$(at::Symbol* _obj)).is_onnx(
+    );
+  }|]
+
+symbol_is_user
+  :: Ptr Symbol
+  -> IO (CBool)
+symbol_is_user _obj =
+  [C.throwBlock| bool { return (*$(at::Symbol* _obj)).is_user(
+    );
+  }|]
+
+symbol_is_caffe2
+  :: Ptr Symbol
+  -> IO (CBool)
+symbol_is_caffe2 _obj =
+  [C.throwBlock| bool { return (*$(at::Symbol* _obj)).is_caffe2(
+    );
+  }|]
+
+symbol_is_dimname
+  :: Ptr Symbol
+  -> IO (CBool)
+symbol_is_dimname _obj =
+  [C.throwBlock| bool { return (*$(at::Symbol* _obj)).is_dimname(
+    );
+  }|]
+
+symbol_toUnqualString
+  :: Ptr Symbol
+  -> IO (Ptr StdString)
+symbol_toUnqualString _obj =
+  [C.throwBlock| std::string* { return new std::string((*$(at::Symbol* _obj)).toUnqualString(
+    ));
+  }|]
+
+symbol_toQualString
+  :: Ptr Symbol
+  -> IO (Ptr StdString)
+symbol_toQualString _obj =
+  [C.throwBlock| std::string* { return new std::string((*$(at::Symbol* _obj)).toQualString(
+    ));
+  }|]
+
+symbol_toDisplayString
+  :: Ptr Symbol
+  -> IO (Ptr StdString)
+symbol_toDisplayString _obj =
+  [C.throwBlock| std::string* { return new std::string((*$(at::Symbol* _obj)).toDisplayString(
+    ));
+  }|]
+
+attr_s
+  :: Ptr StdString
+  -> IO (Ptr Symbol)
+attr_s _s =
+  [C.throwBlock| at::Symbol* { return new at::Symbol(at::Symbol::attr(
+    *$(std::string* _s)));
+  }|]
+
+aten_s
+  :: Ptr StdString
+  -> IO (Ptr Symbol)
+aten_s _s =
+  [C.throwBlock| at::Symbol* { return new at::Symbol(at::Symbol::aten(
+    *$(std::string* _s)));
+  }|]
+
+onnx_s
+  :: Ptr StdString
+  -> IO (Ptr Symbol)
+onnx_s _s =
+  [C.throwBlock| at::Symbol* { return new at::Symbol(at::Symbol::onnx(
+    *$(std::string* _s)));
+  }|]
+
+prim_s
+  :: Ptr StdString
+  -> IO (Ptr Symbol)
+prim_s _s =
+  [C.throwBlock| at::Symbol* { return new at::Symbol(at::Symbol::prim(
+    *$(std::string* _s)));
+  }|]
+
+user_s
+  :: Ptr StdString
+  -> IO (Ptr Symbol)
+user_s _s =
+  [C.throwBlock| at::Symbol* { return new at::Symbol(at::Symbol::user(
+    *$(std::string* _s)));
+  }|]
+
+caffe2_s
+  :: Ptr StdString
+  -> IO (Ptr Symbol)
+caffe2_s _s =
+  [C.throwBlock| at::Symbol* { return new at::Symbol(at::Symbol::caffe2(
+    *$(std::string* _s)));
+  }|]
+
+dimname_s
+  :: Ptr StdString
+  -> IO (Ptr Symbol)
+dimname_s _s =
+  [C.throwBlock| at::Symbol* { return new at::Symbol(at::Symbol::dimname(
+    *$(std::string* _s)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Tensor.hs b/src/Torch/Internal/Unmanaged/Type/Tensor.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Tensor.hs
@@ -0,0 +1,11 @@
+
+module Torch.Internal.Unmanaged.Type.Tensor
+ ( module Torch.Internal.Unmanaged.Type.Tensor.Tensor0
+ , module Torch.Internal.Unmanaged.Type.Tensor.Tensor1
+ , module Torch.Internal.Unmanaged.Type.Tensor.Tensor2
+ , module Torch.Internal.Unmanaged.Type.Tensor.Tensor3
+ ) where
+import Torch.Internal.Unmanaged.Type.Tensor.Tensor0
+import Torch.Internal.Unmanaged.Type.Tensor.Tensor1
+import Torch.Internal.Unmanaged.Type.Tensor.Tensor2
+import Torch.Internal.Unmanaged.Type.Tensor.Tensor3
diff --git a/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor0.hs b/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor0.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor0.hs
@@ -0,0 +1,1906 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Tensor.Tensor0 where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+C.include "<ATen/TensorOperators.h>"
+C.include "<vector>"
+
+
+
+newTensor
+  :: IO (Ptr Tensor)
+newTensor  =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(
+    );
+  }|]
+
+newTensor_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+newTensor_t _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor(
+    *$(at::Tensor* _x));
+  }|]
+
+tensor___dispatch_contiguous
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___dispatch_contiguous _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__dispatch_contiguous(
+    ));
+  }|]
+
+tensor_backward_tbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (())
+tensor_backward_tbb _obj _gradient _keep_graph _create_graph =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj)).backward(
+    *$(at::Tensor* _gradient)
+  , $(bool _keep_graph)
+  , $(bool _create_graph));
+  }|]
+
+tensor_contiguous
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_contiguous _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).contiguous(
+    ));
+  }|]
+
+tensor_cpu
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_cpu _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cpu(
+    ));
+  }|]
+
+tensor_cuda
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_cuda _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cuda(
+    ));
+  }|]
+
+tensor_data_ptr
+  :: Ptr Tensor
+  -> IO (Ptr ())
+tensor_data_ptr _obj =
+  [C.throwBlock| void * { return (*$(at::Tensor* _obj)).data_ptr(
+    );
+  }|]
+
+tensor_defined
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_defined _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).defined(
+    );
+  }|]
+
+tensor_dim
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_dim _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).dim(
+    );
+  }|]
+
+tensor_element_size
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_element_size _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).element_size(
+    );
+  }|]
+
+tensor_get_device
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_get_device _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).get_device(
+    );
+  }|]
+
+tensor_has_names
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_has_names _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).has_names(
+    );
+  }|]
+
+tensor_has_storage
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_has_storage _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).has_storage(
+    );
+  }|]
+
+tensor_hip
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_hip _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).hip(
+    ));
+  }|]
+
+tensor_is_alias_of_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+tensor_is_alias_of_t _obj _other =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_alias_of(
+    *$(at::Tensor* _other));
+  }|]
+
+tensor_is_contiguous
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_contiguous _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_contiguous(
+    );
+  }|]
+
+tensor_is_cuda
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_cuda _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_cuda(
+    );
+  }|]
+
+tensor_is_hip
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_hip _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_hip(
+    );
+  }|]
+
+tensor_is_meta
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_meta _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_meta(
+    );
+  }|]
+
+tensor_is_metal
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_metal _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_metal(
+    );
+  }|]
+
+tensor_is_mkldnn
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_mkldnn _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_mkldnn(
+    );
+  }|]
+
+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_is_quantized
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_quantized _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_quantized(
+    );
+  }|]
+
+tensor_is_same_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+tensor_is_same_t _obj _other =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_same(
+    *$(at::Tensor* _other));
+  }|]
+
+tensor_is_sparse
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_sparse _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_sparse(
+    );
+  }|]
+
+tensor_is_vulkan
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_vulkan _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_vulkan(
+    );
+  }|]
+
+tensor_is_xpu
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_xpu _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_xpu(
+    );
+  }|]
+
+tensor_item_double
+  :: Ptr Tensor
+  -> IO (CDouble)
+tensor_item_double _obj =
+  [C.throwBlock| double { return (*$(at::Tensor* _obj)).item<double>(
+    );
+  }|]
+
+tensor_item_float
+  :: Ptr Tensor
+  -> IO (CFloat)
+tensor_item_float _obj =
+  [C.throwBlock| float { return (*$(at::Tensor* _obj)).item<float>(
+    );
+  }|]
+
+tensor_item_int64_t
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_item_int64_t _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).item<int64_t>(
+    );
+  }|]
+
+tensor_itemsize
+  :: Ptr Tensor
+  -> IO (CSize)
+tensor_itemsize _obj =
+  [C.throwBlock| size_t { return (*$(at::Tensor* _obj)).itemsize(
+    );
+  }|]
+
+tensor_layout
+  :: Ptr Tensor
+  -> IO (Layout)
+tensor_layout _obj =
+  [C.throwBlock| at::Layout { return (*$(at::Tensor* _obj)).layout(
+    );
+  }|]
+
+tensor_metal
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_metal _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).metal(
+    ));
+  }|]
+
+tensor_mutable_grad
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_mutable_grad _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mutable_grad(
+    ));
+  }|]
+
+tensor_nbytes
+  :: Ptr Tensor
+  -> IO (CSize)
+tensor_nbytes _obj =
+  [C.throwBlock| size_t { return (*$(at::Tensor* _obj)).nbytes(
+    );
+  }|]
+
+tensor_ndimension
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_ndimension _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).ndimension(
+    );
+  }|]
+
+tensor_numel
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_numel _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).numel(
+    );
+  }|]
+
+tensor__imul__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (())
+tensor__imul__s _obj _other =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))*=(
+    *$(at::Scalar* _other));
+  }|]
+
+tensor__imul__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+tensor__imul__t _obj _other =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))*=(
+    *$(at::Tensor* _other));
+  }|]
+
+tensor__iadd__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (())
+tensor__iadd__s _obj _other =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))+=(
+    *$(at::Scalar* _other));
+  }|]
+
+tensor__iadd__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+tensor__iadd__t _obj _other =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))+=(
+    *$(at::Tensor* _other));
+  }|]
+
+tensor__isub__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (())
+tensor__isub__s _obj _other =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))-=(
+    *$(at::Scalar* _other));
+  }|]
+
+tensor__isub__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+tensor__isub__t _obj _other =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))-=(
+    *$(at::Tensor* _other));
+  }|]
+
+tensor__idiv__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (())
+tensor__idiv__s _obj _other =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))/=(
+    *$(at::Scalar* _other));
+  }|]
+
+tensor__idiv__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+tensor__idiv__t _obj _other =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))/=(
+    *$(at::Tensor* _other));
+  }|]
+
+tensor__assign__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__assign__t _obj _x =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))=(
+    *$(at::Tensor* _x)));
+  }|]
+
+tensor__at__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor__at__s _obj _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))[(
+    *$(at::Scalar* _index))]);
+  }|]
+
+tensor__at__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__at__t _obj _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))[(
+    *$(at::Tensor* _index))]);
+  }|]
+
+tensor__at__l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor__at__l _obj _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))[(
+    $(int64_t _index))]);
+  }|]
+
+tensor_options
+  :: Ptr Tensor
+  -> IO (Ptr TensorOptions)
+tensor_options _obj =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions((*$(at::Tensor* _obj)).options(
+    ));
+  }|]
+
+tensor_print
+  :: Ptr Tensor
+  -> IO (())
+tensor_print _obj =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj)).print(
+    );
+  }|]
+
+tensor_requires_grad
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_requires_grad _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).requires_grad(
+    );
+  }|]
+
+tensor_reset
+  :: Ptr Tensor
+  -> IO (())
+tensor_reset _obj =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj)).reset(
+    );
+  }|]
+
+tensor_resize__l
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_resize__l _obj _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).resize_(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+tensor_scalar_type
+  :: Ptr Tensor
+  -> IO (ScalarType)
+tensor_scalar_type _obj =
+  [C.throwBlock| at::ScalarType { return (*$(at::Tensor* _obj)).scalar_type(
+    );
+  }|]
+
+tensor_set_requires_grad_b
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_set_requires_grad_b _obj _requires_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).set_requires_grad(
+    $(bool _requires_grad)));
+  }|]
+
+tensor_size_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Int64)
+tensor_size_l _obj _dim =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).size(
+    $(int64_t _dim));
+  }|]
+
+tensor_sizes
+  :: Ptr Tensor
+  -> IO (Ptr IntArray)
+tensor_sizes _obj =
+  [C.throwBlock| std::vector<int64_t>* { return new std::vector<int64_t>((*$(at::Tensor* _obj)).sizes(
+    ).vec());
+  }|]
+
+tensor_storage
+  :: Ptr Tensor
+  -> IO (Ptr Storage)
+tensor_storage _obj =
+  [C.throwBlock| at::Storage* { return new at::Storage((*$(at::Tensor* _obj)).storage(
+    ));
+  }|]
+
+tensor_storage_offset
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_storage_offset _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).storage_offset(
+    );
+  }|]
+
+tensor_stride_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Int64)
+tensor_stride_l _obj _dim =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).stride(
+    $(int64_t _dim));
+  }|]
+
+tensor_strides
+  :: Ptr Tensor
+  -> IO (Ptr IntArray)
+tensor_strides _obj =
+  [C.throwBlock| std::vector<int64_t>* { return new std::vector<int64_t>((*$(at::Tensor* _obj)).strides(
+    ).vec());
+  }|]
+
+tensor_to_Dsbb
+  :: Ptr Tensor
+  -> DeviceType
+  -> ScalarType
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_to_Dsbb _obj _device _dtype _non_blocking _copy =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to(
+    $(at::DeviceType _device)
+  , $(at::ScalarType _dtype)
+  , $(bool _non_blocking)
+  , $(bool _copy)));
+  }|]
+
+tensor_to_sbb
+  :: Ptr Tensor
+  -> ScalarType
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_to_sbb _obj _dtype _non_blocking _copy =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to(
+    $(at::ScalarType _dtype)
+  , $(bool _non_blocking)
+  , $(bool _copy)));
+  }|]
+
+tensor_to_tbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_to_tbb _obj _other _non_blocking _copy =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to(
+    *$(at::Tensor* _other)
+  , $(bool _non_blocking)
+  , $(bool _copy)));
+  }|]
+
+tensor_to_obb
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_to_obb _obj _options _non_blocking _copy =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to(
+    *$(at::TensorOptions* _options)
+  , $(bool _non_blocking)
+  , $(bool _copy)));
+  }|]
+
+tensor_toBackend_B
+  :: Ptr Tensor
+  -> Backend
+  -> IO (Ptr Tensor)
+tensor_toBackend_B _obj _b =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).toBackend(
+    $(at::Backend _b)));
+  }|]
+
+tensor_toString
+  :: Ptr Tensor
+  -> IO (Ptr StdString)
+tensor_toString _obj =
+  [C.throwBlock| std::string* { return new std::string((*$(at::Tensor* _obj)).toString(
+    ));
+  }|]
+
+tensor_toType_s
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_toType_s _obj _t =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).toType(
+    $(at::ScalarType _t)));
+  }|]
+
+tensor_to_dense
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_to_dense _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_dense(
+    ));
+  }|]
+
+tensor_to_mkldnn
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_to_mkldnn _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_mkldnn(
+    ));
+  }|]
+
+tensor_use_count
+  :: Ptr Tensor
+  -> IO (CSize)
+tensor_use_count _obj =
+  [C.throwBlock| size_t { return (*$(at::Tensor* _obj)).use_count(
+    );
+  }|]
+
+tensor_vulkan
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_vulkan _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).vulkan(
+    ));
+  }|]
+
+tensor_weak_use_count
+  :: Ptr Tensor
+  -> IO (CSize)
+tensor_weak_use_count _obj =
+  [C.throwBlock| size_t { return (*$(at::Tensor* _obj)).weak_use_count(
+    );
+  }|]
+
+tensor__backward_ltbb
+  :: Ptr Tensor
+  -> Ptr TensorList
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (())
+tensor__backward_ltbb _obj _inputs _gradient _retain_graph _create_graph =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj))._backward(
+    *$(std::vector<at::Tensor>* _inputs)
+  , *$(at::Tensor* _gradient)
+  , $(bool _retain_graph)
+  , $(bool _create_graph));
+  }|]
+
+tensor_set_data_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (())
+tensor_set_data_t _obj _new_data =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj)).set_data(
+    *$(at::Tensor* _new_data));
+  }|]
+
+tensor_data
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_data _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).data(
+    ));
+  }|]
+
+tensor_is_leaf
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_leaf _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_leaf(
+    );
+  }|]
+
+tensor_output_nr
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_output_nr _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).output_nr(
+    );
+  }|]
+
+tensor__version
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor__version _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj))._version(
+    );
+  }|]
+
+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_retains_grad
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_retains_grad _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).retains_grad(
+    );
+  }|]
+
+tensor__fw_primal_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor__fw_primal_l _obj _level =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._fw_primal(
+    $(int64_t _level)));
+  }|]
+
+tensor_rename__N
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+tensor_rename__N _obj _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).rename_(
+    *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+tensor_rename_N
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+tensor_rename_N _obj _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).rename(
+    *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+tensor_align_to_N
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+tensor_align_to_N _obj _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).align_to(
+    *$(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
+  -> IO (Ptr Tensor)
+tensor_align_as_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).align_as(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_refine_names_N
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+tensor_refine_names_N _obj _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).refine_names(
+    *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+tensor_abs
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_abs _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).abs(
+    ));
+  }|]
+
+tensor_abs_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_abs_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).abs_(
+    ));
+  }|]
+
+tensor_absolute
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_absolute _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).absolute(
+    ));
+  }|]
+
+tensor_absolute_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_absolute_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).absolute_(
+    ));
+  }|]
+
+tensor_angle
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_angle _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).angle(
+    ));
+  }|]
+
+tensor_sgn
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sgn _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sgn(
+    ));
+  }|]
+
+tensor_sgn_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sgn_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sgn_(
+    ));
+  }|]
+
+tensor_chalf_M
+  :: Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_chalf_M _obj _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).chalf(
+    $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor__conj
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__conj _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._conj(
+    ));
+  }|]
+
+tensor_conj
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_conj _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).conj(
+    ));
+  }|]
+
+tensor__conj_physical
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__conj_physical _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._conj_physical(
+    ));
+  }|]
+
+tensor_conj_physical
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_conj_physical _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).conj_physical(
+    ));
+  }|]
+
+tensor_conj_physical_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_conj_physical_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).conj_physical_(
+    ));
+  }|]
+
+tensor_resolve_conj
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_resolve_conj _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).resolve_conj(
+    ));
+  }|]
+
+tensor_resolve_neg
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_resolve_neg _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).resolve_neg(
+    ));
+  }|]
+
+tensor__neg_view
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__neg_view _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._neg_view(
+    ));
+  }|]
+
+tensor_acos
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_acos _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).acos(
+    ));
+  }|]
+
+tensor_acos_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_acos_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).acos_(
+    ));
+  }|]
+
+tensor_arccos
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arccos _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arccos(
+    ));
+  }|]
+
+tensor_arccos_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arccos_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arccos_(
+    ));
+  }|]
+
+tensor_add_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_add_ts _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).add(
+    *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_add__ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_add__ts _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).add_(
+    *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_add_ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_add_ss _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).add(
+    *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_add__ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_add__ss _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).add_(
+    *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_addmv_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addmv_ttss _obj _mat _vec _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addmv(
+    *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_addmv__ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addmv__ttss _obj _mat _vec _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addmv_(
+    *$(at::Tensor* _mat)
+  , *$(at::Tensor* _vec)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_addr_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addr_ttss _obj _vec1 _vec2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addr(
+    *$(at::Tensor* _vec1)
+  , *$(at::Tensor* _vec2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_addr__ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addr__ttss _obj _vec1 _vec2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addr_(
+    *$(at::Tensor* _vec1)
+  , *$(at::Tensor* _vec2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor__is_all_true
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__is_all_true _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._is_all_true(
+    ));
+  }|]
+
+tensor__is_any_true
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__is_any_true _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._is_any_true(
+    ));
+  }|]
+
+tensor_all_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_all_lb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).all(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_all_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_all_nb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).all(
+    *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_allclose_tddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (CBool)
+tensor_allclose_tddb _obj _other _rtol _atol _equal_nan =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).allclose(
+    *$(at::Tensor* _other)
+  , $(double _rtol)
+  , $(double _atol)
+  , $(bool _equal_nan));
+  }|]
+
+tensor_any_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_any_lb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).any(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_any_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_any_nb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).any(
+    *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_argmax_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_argmax_lb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).argmax(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_argmin_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_argmin_lb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).argmin(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_acosh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_acosh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).acosh(
+    ));
+  }|]
+
+tensor_acosh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_acosh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).acosh_(
+    ));
+  }|]
+
+tensor_arccosh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arccosh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arccosh(
+    ));
+  }|]
+
+tensor_arccosh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arccosh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arccosh_(
+    ));
+  }|]
+
+tensor_asinh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_asinh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).asinh(
+    ));
+  }|]
+
+tensor_asinh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_asinh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).asinh_(
+    ));
+  }|]
+
+tensor_arcsinh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arcsinh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arcsinh(
+    ));
+  }|]
+
+tensor_arcsinh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arcsinh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arcsinh_(
+    ));
+  }|]
+
+tensor_atanh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_atanh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).atanh(
+    ));
+  }|]
+
+tensor_atanh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_atanh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).atanh_(
+    ));
+  }|]
+
+tensor_arctanh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arctanh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arctanh(
+    ));
+  }|]
+
+tensor_arctanh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arctanh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arctanh_(
+    ));
+  }|]
+
+tensor_as_strided_lll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_as_strided_lll _obj _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).as_strided(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+tensor_as_strided__lll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_as_strided__lll _obj _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).as_strided_(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+tensor_asin
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_asin _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).asin(
+    ));
+  }|]
+
+tensor_asin_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_asin_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).asin_(
+    ));
+  }|]
+
+tensor_arcsin
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arcsin _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arcsin(
+    ));
+  }|]
+
+tensor_arcsin_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arcsin_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arcsin_(
+    ));
+  }|]
+
+tensor_atan
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_atan _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).atan(
+    ));
+  }|]
+
+tensor_atan_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_atan_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).atan_(
+    ));
+  }|]
+
+tensor_arctan
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arctan _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arctan(
+    ));
+  }|]
+
+tensor_arctan_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arctan_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arctan_(
+    ));
+  }|]
+
+tensor_baddbmm_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_baddbmm_ttss _obj _batch1 _batch2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).baddbmm(
+    *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_baddbmm__ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_baddbmm__ttss _obj _batch1 _batch2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).baddbmm_(
+    *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_bernoulli_G
+  :: Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_bernoulli_G _obj _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bernoulli(
+    *$(at::Generator* _generator)));
+  }|]
+
+tensor_bernoulli__tG
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_bernoulli__tG _obj _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bernoulli_(
+    *$(at::Tensor* _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_bernoulli__dG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_bernoulli__dG _obj _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bernoulli_(
+    $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_bernoulli_dG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_bernoulli_dG _obj _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bernoulli(
+    $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_bincount_tl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_bincount_tl _obj _weights _minlength =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bincount(
+    *$(at::Tensor* _weights)
+  , $(int64_t _minlength)));
+  }|]
+
+tensor_bitwise_not
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_not _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_not(
+    ));
+  }|]
+
+tensor_bitwise_not_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_not_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_not_(
+    ));
+  }|]
+
+tensor_copysign_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_copysign_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).copysign(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_copysign__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_copysign__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).copysign_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_copysign_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_copysign_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).copysign(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_copysign__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_copysign__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).copysign_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_logical_not
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logical_not _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logical_not(
+    ));
+  }|]
+
+tensor_logical_not_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logical_not_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logical_not_(
+    ));
+  }|]
+
+tensor_logical_xor_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logical_xor_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logical_xor(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_logical_xor__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logical_xor__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logical_xor_(
+    *$(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
+  -> IO (Ptr Tensor)
+tensor_bmm_t _obj _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bmm(
+    *$(at::Tensor* _mat2)));
+  }|]
+
+tensor_broadcast_to_l
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_broadcast_to_l _obj _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).broadcast_to(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+tensor_ceil
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ceil _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ceil(
+    ));
+  }|]
+
+tensor_ceil_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ceil_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ceil_(
+    ));
+  }|]
+
+tensor_unsafe_chunk_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_unsafe_chunk_ll _obj _chunks _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).unsafe_chunk(
+    $(int64_t _chunks)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_chunk_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_chunk_ll _obj _chunks _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).chunk(
+    $(int64_t _chunks)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_tensor_split_tl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_tensor_split_tl _obj _tensor_indices_or_sections _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).tensor_split(
+    *$(at::Tensor* _tensor_indices_or_sections)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_clamp_ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_clamp_ss _obj _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp(
+    *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+tensor_clamp_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_clamp_tt _obj _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+tensor_clamp__ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_clamp__ss _obj _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_(
+    *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+tensor_clamp__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_clamp__tt _obj _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+tensor_clamp_max_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_clamp_max_s _obj _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_max(
+    *$(at::Scalar* _max)));
+  }|]
+
+tensor_clamp_max_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_clamp_max_t _obj _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_max(
+    *$(at::Tensor* _max)));
+  }|]
+
+tensor_clamp_max__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_clamp_max__s _obj _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_max_(
+    *$(at::Scalar* _max)));
+  }|]
+
+tensor_clamp_max__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_clamp_max__t _obj _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_max_(
+    *$(at::Tensor* _max)));
+  }|]
+
+tensor_clamp_min_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_clamp_min_s _obj _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_min(
+    *$(at::Scalar* _min)));
+  }|]
+
+tensor_clamp_min_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_clamp_min_t _obj _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_min(
+    *$(at::Tensor* _min)));
+  }|]
+
+tensor_clamp_min__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_clamp_min__s _obj _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_min_(
+    *$(at::Scalar* _min)));
+  }|]
+
+tensor_clamp_min__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_clamp_min__t _obj _min =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clamp_min_(
+    *$(at::Tensor* _min)));
+  }|]
+
+tensor_clip_ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_clip_ss _obj _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clip(
+    *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+tensor_clip_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_clip_tt _obj _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clip(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+tensor_clip__ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_clip__ss _obj _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clip_(
+    *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+tensor_clip__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_clip__tt _obj _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clip_(
+    *$(at::Tensor* _min)
+  , *$(at::Tensor* _max)));
+  }|]
+
+tensor_contiguous_M
+  :: Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_contiguous_M _obj _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).contiguous(
+    $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor_copy__tb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_copy__tb _obj _src _non_blocking =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).copy_(
+    *$(at::Tensor* _src)
+  , $(bool _non_blocking)));
+  }|]
+
+tensor_cos
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_cos _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cos(
+    ));
+  }|]
+
+tensor_cos_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_cos_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cos_(
+    ));
+  }|]
+
+tensor_cosh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_cosh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cosh(
+    ));
+  }|]
+
+tensor_cosh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_cosh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cosh_(
+    ));
+  }|]
+
+tensor_cov_ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_cov_ltt _obj _correction _fweights _aweights =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cov(
+    $(int64_t _correction)
+  , *$(at::Tensor* _fweights)
+  , *$(at::Tensor* _aweights)));
+  }|]
+
+tensor_corrcoef
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_corrcoef _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).corrcoef(
+    ));
+  }|]
+
+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)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor1.hs b/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor1.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor1.hs
@@ -0,0 +1,2042 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Tensor.Tensor1 where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+C.include "<ATen/TensorOperators.h>"
+C.include "<vector>"
+
+
+
+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_cumprod_ls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_cumprod_ls _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cumprod(
+    $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_cumprod__ls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_cumprod__ls _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cumprod_(
+    $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_cumprod_ns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_cumprod_ns _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cumprod(
+    *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_cumprod__ns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_cumprod__ns _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cumprod_(
+    *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_cumsum_ls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_cumsum_ls _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cumsum(
+    $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_cumsum__ls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_cumsum__ls _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cumsum_(
+    $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_cumsum_ns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_cumsum_ns _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cumsum(
+    *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_cumsum__ns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_cumsum__ns _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cumsum_(
+    *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_diag_embed_lll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_diag_embed_lll _obj _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).diag_embed(
+    $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+tensor_diagflat_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_diagflat_l _obj _offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).diagflat(
+    $(int64_t _offset)));
+  }|]
+
+tensor_diagonal_lll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_diagonal_lll _obj _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).diagonal(
+    $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(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
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_fill_diagonal__sb _obj _fill_value _wrap =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fill_diagonal_(
+    *$(at::Scalar* _fill_value)
+  , $(bool _wrap)));
+  }|]
+
+tensor_diff_lltt
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_diff_lltt _obj _n _dim _prepend _append =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).diff(
+    $(int64_t _n)
+  , $(int64_t _dim)
+  , *$(at::Tensor* _prepend)
+  , *$(at::Tensor* _append)));
+  }|]
+
+tensor_div_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_div_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).div(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_div__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_div__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).div_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_div_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_div_ts _obj _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).div(
+    *$(at::Tensor* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+tensor_div__ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_div__ts _obj _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).div_(
+    *$(at::Tensor* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+tensor_div_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_div_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).div(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_div__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_div__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).div_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_div_ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_div_ss _obj _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).div(
+    *$(at::Scalar* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+tensor_div__ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_div__ss _obj _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).div_(
+    *$(at::Scalar* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+tensor_divide_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_divide_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).divide(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_divide__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_divide__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).divide_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_divide_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_divide_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).divide(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_divide__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_divide__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).divide_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_divide_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_divide_ts _obj _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).divide(
+    *$(at::Tensor* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+tensor_divide__ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_divide__ts _obj _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).divide_(
+    *$(at::Tensor* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+tensor_divide_ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_divide_ss _obj _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).divide(
+    *$(at::Scalar* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+tensor_divide__ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_divide__ss _obj _other _rounding_mode =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).divide_(
+    *$(at::Scalar* _other)
+  , *$(std::string* _rounding_mode)));
+  }|]
+
+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_dot_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_dot_t _obj _tensor =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).dot(
+    *$(at::Tensor* _tensor)));
+  }|]
+
+tensor_vdot_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_vdot_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).vdot(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_new_empty_lo
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+tensor_new_empty_lo _obj _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).new_empty(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+tensor_new_empty_strided_llo
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+tensor_new_empty_strided_llo _obj _size _stride _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).new_empty_strided(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+tensor_new_full_lso
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr Scalar
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+tensor_new_full_lso _obj _size _fill_value _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).new_full(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::Scalar* _fill_value)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+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_new_ones_lo
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr TensorOptions
+  -> IO (Ptr Tensor)
+tensor_new_ones_lo _obj _size _options =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).new_ones(
+    *$(std::vector<int64_t>* _size)
+  , *$(at::TensorOptions* _options)));
+  }|]
+
+tensor_resize__lM
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_resize__lM _obj _size _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).resize_(
+    *$(std::vector<int64_t>* _size)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor_erf
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_erf _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).erf(
+    ));
+  }|]
+
+tensor_erf_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_erf_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).erf_(
+    ));
+  }|]
+
+tensor_erfc
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_erfc _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).erfc(
+    ));
+  }|]
+
+tensor_erfc_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_erfc_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).erfc_(
+    ));
+  }|]
+
+tensor_exp
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_exp _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).exp(
+    ));
+  }|]
+
+tensor_exp_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_exp_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).exp_(
+    ));
+  }|]
+
+tensor_exp2
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_exp2 _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).exp2(
+    ));
+  }|]
+
+tensor_exp2_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_exp2_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).exp2_(
+    ));
+  }|]
+
+tensor_expm1
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_expm1 _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).expm1(
+    ));
+  }|]
+
+tensor_expm1_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_expm1_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).expm1_(
+    ));
+  }|]
+
+tensor_expand_lb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_expand_lb _obj _size _implicit =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).expand(
+    *$(std::vector<int64_t>* _size)
+  , $(bool _implicit)));
+  }|]
+
+tensor_expand_as_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_expand_as_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).expand_as(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_flatten_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_flatten_ll _obj _start_dim _end_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).flatten(
+    $(int64_t _start_dim)
+  , $(int64_t _end_dim)));
+  }|]
+
+tensor_flatten_lln
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+tensor_flatten_lln _obj _start_dim _end_dim _out_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).flatten(
+    $(int64_t _start_dim)
+  , $(int64_t _end_dim)
+  , *$(at::Dimname* _out_dim)));
+  }|]
+
+tensor_flatten_nnn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+tensor_flatten_nnn _obj _start_dim _end_dim _out_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).flatten(
+    *$(at::Dimname* _start_dim)
+  , *$(at::Dimname* _end_dim)
+  , *$(at::Dimname* _out_dim)));
+  }|]
+
+tensor_flatten_Nn
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+tensor_flatten_Nn _obj _dims _out_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).flatten(
+    *$(std::vector<at::Dimname>* _dims)
+  , *$(at::Dimname* _out_dim)));
+  }|]
+
+tensor_unflatten_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_unflatten_ll _obj _dim _sizes =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).unflatten(
+    $(int64_t _dim)
+  , *$(std::vector<int64_t>* _sizes)));
+  }|]
+
+tensor_unflatten_nlN
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr IntArray
+  -> Ptr DimnameList
+  -> IO (Ptr Tensor)
+tensor_unflatten_nlN _obj _dim _sizes _names =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).unflatten(
+    *$(at::Dimname* _dim)
+  , *$(std::vector<int64_t>* _sizes)
+  , *$(std::vector<at::Dimname>* _names)));
+  }|]
+
+tensor_fill__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_fill__s _obj _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fill_(
+    *$(at::Scalar* _value)));
+  }|]
+
+tensor_fill__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_fill__t _obj _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fill_(
+    *$(at::Tensor* _value)));
+  }|]
+
+tensor_floor
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_floor _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).floor(
+    ));
+  }|]
+
+tensor_floor_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_floor_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).floor_(
+    ));
+  }|]
+
+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)
+tensor_frac _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).frac(
+    ));
+  }|]
+
+tensor_frac_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_frac_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).frac_(
+    ));
+  }|]
+
+tensor_gcd_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_gcd_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).gcd(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_gcd__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_gcd__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).gcd_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_lcm_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lcm_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lcm(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_lcm__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lcm__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lcm_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_index_l
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> IO (Ptr Tensor)
+tensor_index_l _obj _indices =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index(
+    *$(c10::List<c10::optional<at::Tensor>>* _indices)));
+  }|]
+
+tensor_index_copy__ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_copy__ltt _obj _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_copy_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+tensor_index_copy_ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_copy_ltt _obj _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_copy(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+tensor_index_copy__ntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_copy__ntt _obj _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_copy_(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+tensor_index_copy_ntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_copy_ntt _obj _dim _index _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_copy(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)));
+  }|]
+
+tensor_index_put__ltb
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_index_put__ltb _obj _indices _values _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_put_(
+    *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)));
+  }|]
+
+tensor_index_put_ltb
+  :: Ptr Tensor
+  -> Ptr (C10List (C10Optional Tensor))
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_index_put_ltb _obj _indices _values _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_put(
+    *$(c10::List<c10::optional<at::Tensor>>* _indices)
+  , *$(at::Tensor* _values)
+  , $(bool _accumulate)));
+  }|]
+
+tensor_isclose_tddb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_isclose_tddb _obj _other _rtol _atol _equal_nan =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).isclose(
+    *$(at::Tensor* _other)
+  , $(double _rtol)
+  , $(double _atol)
+  , $(bool _equal_nan)));
+  }|]
+
+tensor_isnan
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_isnan _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).isnan(
+    ));
+  }|]
+
+tensor_is_distributed
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_distributed _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_distributed(
+    );
+  }|]
+
+tensor_is_floating_point
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_floating_point _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_floating_point(
+    );
+  }|]
+
+tensor_is_complex
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_complex _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_complex(
+    );
+  }|]
+
+tensor_is_conj
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_conj _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_conj(
+    );
+  }|]
+
+tensor__is_zerotensor
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor__is_zerotensor _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj))._is_zerotensor(
+    );
+  }|]
+
+tensor_is_neg
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_neg _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_neg(
+    );
+  }|]
+
+tensor_isreal
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_isreal _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).isreal(
+    ));
+  }|]
+
+tensor_is_nonzero
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_nonzero _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_nonzero(
+    );
+  }|]
+
+tensor_is_same_size_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+tensor_is_same_size_t _obj _other =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_same_size(
+    *$(at::Tensor* _other));
+  }|]
+
+tensor_is_signed
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_signed _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_signed(
+    );
+  }|]
+
+tensor_is_inference
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_inference _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_inference(
+    );
+  }|]
+
+tensor_kron_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_kron_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).kron(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_kthvalue_llb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_kthvalue_llb _obj _k _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).kthvalue(
+    $(int64_t _k)
+  , $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_kthvalue_lnb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_kthvalue_lnb _obj _k _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).kthvalue(
+    $(int64_t _k)
+  , *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_nan_to_num_ddd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+tensor_nan_to_num_ddd _obj _nan _posinf _neginf =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nan_to_num(
+    $(double _nan)
+  , $(double _posinf)
+  , $(double _neginf)));
+  }|]
+
+tensor_nan_to_num__ddd
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> CDouble
+  -> IO (Ptr Tensor)
+tensor_nan_to_num__ddd _obj _nan _posinf _neginf =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nan_to_num_(
+    $(double _nan)
+  , $(double _posinf)
+  , $(double _neginf)));
+  }|]
+
+tensor_ldexp_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ldexp_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ldexp(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_ldexp__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ldexp__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ldexp_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_log
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_log _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log(
+    ));
+  }|]
+
+tensor_log_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_log_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log_(
+    ));
+  }|]
+
+tensor_log10
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_log10 _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log10(
+    ));
+  }|]
+
+tensor_log10_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_log10_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log10_(
+    ));
+  }|]
+
+tensor_log1p
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_log1p _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log1p(
+    ));
+  }|]
+
+tensor_log1p_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_log1p_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log1p_(
+    ));
+  }|]
+
+tensor_log2
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_log2 _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log2(
+    ));
+  }|]
+
+tensor_log2_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_log2_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log2_(
+    ));
+  }|]
+
+tensor_logaddexp_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logaddexp_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logaddexp(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_logaddexp2_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logaddexp2_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logaddexp2(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_xlogy_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_xlogy_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).xlogy(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_xlogy_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_xlogy_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).xlogy(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_xlogy__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_xlogy__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).xlogy_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_xlogy__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_xlogy__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).xlogy_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_log_softmax_ls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_log_softmax_ls _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log_softmax(
+    $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_log_softmax_ns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_log_softmax_ns _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log_softmax(
+    *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_logcumsumexp_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_logcumsumexp_l _obj _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logcumsumexp(
+    $(int64_t _dim)));
+  }|]
+
+tensor_logcumsumexp_n
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+tensor_logcumsumexp_n _obj _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logcumsumexp(
+    *$(at::Dimname* _dim)));
+  }|]
+
+tensor_logsumexp_lb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_logsumexp_lb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logsumexp(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_logsumexp_Nb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_logsumexp_Nb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logsumexp(
+    *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_matmul_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_matmul_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).matmul(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_matrix_power_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_matrix_power_l _obj _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).matrix_power(
+    $(int64_t _n)));
+  }|]
+
+tensor_matrix_exp
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_matrix_exp _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).matrix_exp(
+    ));
+  }|]
+
+tensor_aminmax_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_aminmax_lb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).aminmax(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_max_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_max_lb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).max(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_max_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_max_nb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).max(
+    *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_amax_lb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_amax_lb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).amax(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_mean_s
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_mean_s _obj _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mean(
+    $(at::ScalarType _dtype)));
+  }|]
+
+tensor_mean_lbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_mean_lbs _obj _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mean(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_mean_Nbs
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_mean_Nbs _obj _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mean(
+    *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_nanmean_lbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_nanmean_lbs _obj _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nanmean(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_median
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_median _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).median(
+    ));
+  }|]
+
+tensor_median_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_median_lb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).median(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_median_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_median_nb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).median(
+    *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_nanmedian
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_nanmedian _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nanmedian(
+    ));
+  }|]
+
+tensor_nanmedian_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_nanmedian_lb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).nanmedian(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_nanmedian_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_nanmedian_nb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).nanmedian(
+    *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_min_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_min_lb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).min(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_min_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_min_nb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).min(
+    *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_amin_lb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_amin_lb _obj _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).amin(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_mm_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_mm_t _obj _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mm(
+    *$(at::Tensor* _mat2)));
+  }|]
+
+tensor_mode_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_mode_lb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).mode(
+    $(int64_t _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_mode_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_mode_nb _obj _dim _keepdim =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).mode(
+    *$(at::Dimname* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_mul_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_mul_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mul(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_mul__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_mul__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mul_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_mul_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_mul_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mul(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_mul__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_mul__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mul_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_multiply_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_multiply_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).multiply(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_multiply__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_multiply__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).multiply_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_multiply_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_multiply_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).multiply(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_multiply__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_multiply__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).multiply_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_mv_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_mv_t _obj _vec =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mv(
+    *$(at::Tensor* _vec)));
+  }|]
+
+tensor_mvlgamma_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_mvlgamma_l _obj _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mvlgamma(
+    $(int64_t _p)));
+  }|]
+
+tensor_mvlgamma__l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_mvlgamma__l _obj _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mvlgamma_(
+    $(int64_t _p)));
+  }|]
+
+tensor_narrow_copy_lll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_narrow_copy_lll _obj _dim _start _length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).narrow_copy(
+    $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _length)));
+  }|]
+
+tensor_narrow_lll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_narrow_lll _obj _dim _start _length =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).narrow(
+    $(int64_t _dim)
+  , $(int64_t _start)
+  , $(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
+  -> IO (Ptr Tensor)
+tensor_permute_l _obj _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).permute(
+    *$(std::vector<int64_t>* _dims)));
+  }|]
+
+tensor_numpy_T
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_numpy_T _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).numpy_T(
+    ));
+  }|]
+
+tensor_matrix_H
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_matrix_H _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).matrix_H(
+    ));
+  }|]
+
+tensor_mT
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_mT _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mT(
+    ));
+  }|]
+
+tensor_mH
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_mH _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).mH(
+    ));
+  }|]
+
+tensor_adjoint
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_adjoint _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).adjoint(
+    ));
+  }|]
+
+tensor_is_pinned_D
+  :: Ptr Tensor
+  -> DeviceType
+  -> IO (CBool)
+tensor_is_pinned_D _obj _device =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_pinned(
+    $(at::DeviceType _device));
+  }|]
+
+tensor_pin_memory_D
+  :: Ptr Tensor
+  -> DeviceType
+  -> IO (Ptr Tensor)
+tensor_pin_memory_D _obj _device =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).pin_memory(
+    $(at::DeviceType _device)));
+  }|]
+
+tensor_pinverse_d
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+tensor_pinverse_d _obj _rcond =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).pinverse(
+    $(double _rcond)));
+  }|]
+
+tensor_rad2deg
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_rad2deg _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).rad2deg(
+    ));
+  }|]
+
+tensor_rad2deg_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_rad2deg_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).rad2deg_(
+    ));
+  }|]
+
+tensor_deg2rad
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_deg2rad _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).deg2rad(
+    ));
+  }|]
+
+tensor_deg2rad_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_deg2rad_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).deg2rad_(
+    ));
+  }|]
+
+tensor_ravel
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ravel _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ravel(
+    ));
+  }|]
+
+tensor_reciprocal
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_reciprocal _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).reciprocal(
+    ));
+  }|]
+
+tensor_reciprocal_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_reciprocal_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).reciprocal_(
+    ));
+  }|]
+
+tensor_neg
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_neg _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).neg(
+    ));
+  }|]
+
+tensor_neg_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_neg_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).neg_(
+    ));
+  }|]
+
+tensor_negative
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_negative _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).negative(
+    ));
+  }|]
+
+tensor_negative_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_negative_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).negative_(
+    ));
+  }|]
+
+tensor_repeat_l
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_repeat_l _obj _repeats =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).repeat(
+    *$(std::vector<int64_t>* _repeats)));
+  }|]
+
+tensor_repeat_interleave_tll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_repeat_interleave_tll _obj _repeats _dim _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).repeat_interleave(
+    *$(at::Tensor* _repeats)
+  , $(int64_t _dim)
+  , $(int64_t _output_size)));
+  }|]
+
+tensor_repeat_interleave_lll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_repeat_interleave_lll _obj _repeats _dim _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).repeat_interleave(
+    $(int64_t _repeats)
+  , $(int64_t _dim)
+  , $(int64_t _output_size)));
+  }|]
+
+tensor_reshape_l
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_reshape_l _obj _shape =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).reshape(
+    *$(std::vector<int64_t>* _shape)));
+  }|]
+
+tensor__reshape_alias_ll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor__reshape_alias_ll _obj _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._reshape_alias(
+    *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+tensor_reshape_as_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_reshape_as_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).reshape_as(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_round
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_round _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).round(
+    ));
+  }|]
+
+tensor_round_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_round_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).round_(
+    ));
+  }|]
+
+tensor_round_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_round_l _obj _decimals =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).round(
+    $(int64_t _decimals)));
+  }|]
+
+tensor_round__l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_round__l _obj _decimals =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).round_(
+    $(int64_t _decimals)));
+  }|]
+
+tensor_relu
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_relu _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).relu(
+    ));
+  }|]
+
+tensor_relu_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_relu_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).relu_(
+    ));
+  }|]
+
+tensor_prelu_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_prelu_t _obj _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).prelu(
+    *$(at::Tensor* _weight)));
+  }|]
+
+tensor_hardshrink_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_hardshrink_s _obj _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).hardshrink(
+    *$(at::Scalar* _lambd)));
+  }|]
+
+tensor_hardshrink_backward_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_hardshrink_backward_ts _obj _self _lambd =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).hardshrink_backward(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _lambd)));
+  }|]
+
+tensor_rsqrt
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_rsqrt _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).rsqrt(
+    ));
+  }|]
+
+tensor_rsqrt_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_rsqrt_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).rsqrt_(
+    ));
+  }|]
+
+tensor_select_nl
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_select_nl _obj _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).select(
+    *$(at::Dimname* _dim)
+  , $(int64_t _index)));
+  }|]
+
+tensor_select_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_select_ll _obj _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).select(
+    $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+tensor_sigmoid
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sigmoid _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sigmoid(
+    ));
+  }|]
+
+tensor_sigmoid_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sigmoid_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sigmoid_(
+    ));
+  }|]
+
+tensor_logit_d
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+tensor_logit_d _obj _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logit(
+    $(double _eps)));
+  }|]
+
+tensor_logit__d
+  :: Ptr Tensor
+  -> CDouble
+  -> IO (Ptr Tensor)
+tensor_logit__d _obj _eps =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logit_(
+    $(double _eps)));
+  }|]
+
+tensor_sin
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sin _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sin(
+    ));
+  }|]
+
+tensor_sin_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sin_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sin_(
+    ));
+  }|]
+
+tensor_sinc
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sinc _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sinc(
+    ));
+  }|]
+
+tensor_sinc_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sinc_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sinc_(
+    ));
+  }|]
+
+tensor_sinh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sinh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sinh(
+    ));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor2.hs b/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor2.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor2.hs
@@ -0,0 +1,2271 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Tensor.Tensor2 where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+C.include "<ATen/TensorOperators.h>"
+C.include "<vector>"
+
+
+
+tensor_sinh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sinh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sinh_(
+    ));
+  }|]
+
+tensor_detach
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_detach _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).detach(
+    ));
+  }|]
+
+tensor_detach_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_detach_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).detach_(
+    ));
+  }|]
+
+tensor_size_n
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Int64)
+tensor_size_n _obj _dim =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).size(
+    *$(at::Dimname* _dim));
+  }|]
+
+tensor_slice_llll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_slice_llll _obj _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).slice(
+    $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+tensor_slice_scatter_tllll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_slice_scatter_tllll _obj _src _dim _start _end _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).slice_scatter(
+    *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _start)
+  , $(int64_t _end)
+  , $(int64_t _step)));
+  }|]
+
+tensor_select_scatter_tll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_select_scatter_tll _obj _src _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).select_scatter(
+    *$(at::Tensor* _src)
+  , $(int64_t _dim)
+  , $(int64_t _index)));
+  }|]
+
+tensor_diagonal_scatter_tlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_diagonal_scatter_tlll _obj _src _offset _dim1 _dim2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).diagonal_scatter(
+    *$(at::Tensor* _src)
+  , $(int64_t _offset)
+  , $(int64_t _dim1)
+  , $(int64_t _dim2)));
+  }|]
+
+tensor_as_strided_scatter_tlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_as_strided_scatter_tlll _obj _src _size _stride _storage_offset =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).as_strided_scatter(
+    *$(at::Tensor* _src)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)
+  , $(int64_t _storage_offset)));
+  }|]
+
+tensor_smm_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_smm_t _obj _mat2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).smm(
+    *$(at::Tensor* _mat2)));
+  }|]
+
+tensor_softmax_ls
+  :: Ptr Tensor
+  -> Int64
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_softmax_ls _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).softmax(
+    $(int64_t _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_softmax_ns
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_softmax_ns _obj _dim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).softmax(
+    *$(at::Dimname* _dim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_unsafe_split_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_unsafe_split_ll _obj _split_size _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).unsafe_split(
+    $(int64_t _split_size)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_split_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_split_ll _obj _split_size _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).split(
+    $(int64_t _split_size)
+  , $(int64_t _dim)));
+  }|]
+
+-- tensor_split_ll
+--   :: Ptr Tensor
+--   -> Ptr IntArray
+--   -> Int64
+--   -> IO (Ptr TensorList)
+-- tensor_split_ll _obj _split_size _dim =
+--   [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).split(
+--     *$(std::vector<int64_t>* _split_size)
+--   , $(int64_t _dim)));
+--   }|]
+
+tensor_unsafe_split_with_sizes_ll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_unsafe_split_with_sizes_ll _obj _split_sizes _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).unsafe_split_with_sizes(
+    *$(std::vector<int64_t>* _split_sizes)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_split_with_sizes_ll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_split_with_sizes_ll _obj _split_sizes _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).split_with_sizes(
+    *$(std::vector<int64_t>* _split_sizes)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_squeeze
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_squeeze _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).squeeze(
+    ));
+  }|]
+
+tensor_squeeze_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_squeeze_l _obj _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).squeeze(
+    $(int64_t _dim)));
+  }|]
+
+tensor_squeeze_n
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+tensor_squeeze_n _obj _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).squeeze(
+    *$(at::Dimname* _dim)));
+  }|]
+
+-- tensor_squeeze_l
+--   :: Ptr Tensor
+--   -> Ptr IntArray
+--   -> IO (Ptr Tensor)
+-- tensor_squeeze_l _obj _dim =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).squeeze(
+--     *$(std::vector<int64_t>* _dim)));
+--   }|]
+
+tensor_squeeze_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_squeeze_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).squeeze_(
+    ));
+  }|]
+
+tensor_squeeze__l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_squeeze__l _obj _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).squeeze_(
+    $(int64_t _dim)));
+  }|]
+
+-- tensor_squeeze__l
+--   :: Ptr Tensor
+--   -> Ptr IntArray
+--   -> IO (Ptr Tensor)
+-- tensor_squeeze__l _obj _dim =
+--   [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).squeeze_(
+--     *$(std::vector<int64_t>* _dim)));
+--   }|]
+
+tensor_squeeze__n
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+tensor_squeeze__n _obj _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).squeeze_(
+    *$(at::Dimname* _dim)));
+  }|]
+
+tensor_sspaddmm_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_sspaddmm_ttss _obj _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sspaddmm(
+    *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_stft_llltbbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_stft_llltbbb _obj _n_fft _hop_length _win_length _window _normalized _onesided _return_complex =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).stft(
+    $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _normalized)
+  , $(bool _onesided)
+  , $(bool _return_complex)));
+  }|]
+
+tensor_stft_llltbsbbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> Ptr StdString
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_stft_llltbsbbb _obj _n_fft _hop_length _win_length _window _center _pad_mode _normalized _onesided _return_complex =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).stft(
+    $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , *$(std::string* _pad_mode)
+  , $(bool _normalized)
+  , $(bool _onesided)
+  , $(bool _return_complex)));
+  }|]
+
+tensor_istft_llltbbblb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_istft_llltbbblb _obj _n_fft _hop_length _win_length _window _center _normalized _onesided _length _return_complex =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).istft(
+    $(int64_t _n_fft)
+  , $(int64_t _hop_length)
+  , $(int64_t _win_length)
+  , *$(at::Tensor* _window)
+  , $(bool _center)
+  , $(bool _normalized)
+  , $(bool _onesided)
+  , $(int64_t _length)
+  , $(bool _return_complex)));
+  }|]
+
+tensor_stride_n
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Int64)
+tensor_stride_n _obj _dim =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).stride(
+    *$(at::Dimname* _dim));
+  }|]
+
+tensor_sum_s
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_sum_s _obj _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sum(
+    $(at::ScalarType _dtype)));
+  }|]
+
+tensor_sum_lbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_sum_lbs _obj _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sum(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_sum_Nbs
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_sum_Nbs _obj _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sum(
+    *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_nansum_lbs
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_nansum_lbs _obj _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nansum(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_sum_to_size_l
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_sum_to_size_l _obj _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sum_to_size(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+tensor_sqrt
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sqrt _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sqrt(
+    ));
+  }|]
+
+tensor_sqrt_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sqrt_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sqrt_(
+    ));
+  }|]
+
+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
+  -> IO (Ptr Tensor)
+tensor_std_b _obj _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).std(
+    $(bool _unbiased)));
+  }|]
+
+tensor_std_lbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_std_lbb _obj _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).std(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_std_llb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_std_llb _obj _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).std(
+    *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_std_Nbb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_std_Nbb _obj _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).std(
+    *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_std_Nlb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_std_Nlb _obj _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).std(
+    *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_prod_s
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_prod_s _obj _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).prod(
+    $(at::ScalarType _dtype)));
+  }|]
+
+tensor_prod_lbs
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_prod_lbs _obj _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).prod(
+    $(int64_t _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_prod_nbs
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_prod_nbs _obj _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).prod(
+    *$(at::Dimname* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_t
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_t _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).t(
+    ));
+  }|]
+
+tensor_t_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_t_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).t_(
+    ));
+  }|]
+
+tensor_tan
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_tan _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).tan(
+    ));
+  }|]
+
+tensor_tan_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_tan_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).tan_(
+    ));
+  }|]
+
+tensor_tanh
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_tanh _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).tanh(
+    ));
+  }|]
+
+tensor_tanh_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_tanh_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).tanh_(
+    ));
+  }|]
+
+tensor_tile_l
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_tile_l _obj _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).tile(
+    *$(std::vector<int64_t>* _dims)));
+  }|]
+
+tensor_transpose_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_transpose_ll _obj _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).transpose(
+    $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+tensor_transpose_nn
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Dimname
+  -> IO (Ptr Tensor)
+tensor_transpose_nn _obj _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).transpose(
+    *$(at::Dimname* _dim0)
+  , *$(at::Dimname* _dim1)));
+  }|]
+
+tensor_transpose__ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_transpose__ll _obj _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).transpose_(
+    $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+tensor_flip_l
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_flip_l _obj _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).flip(
+    *$(std::vector<int64_t>* _dims)));
+  }|]
+
+tensor_fliplr
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_fliplr _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fliplr(
+    ));
+  }|]
+
+tensor_flipud
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_flipud _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).flipud(
+    ));
+  }|]
+
+tensor_roll_ll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_roll_ll _obj _shifts _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).roll(
+    *$(std::vector<int64_t>* _shifts)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+tensor_rot90_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_rot90_ll _obj _k _dims =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).rot90(
+    $(int64_t _k)
+  , *$(std::vector<int64_t>* _dims)));
+  }|]
+
+tensor__nested_tensor_size
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__nested_tensor_size _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._nested_tensor_size(
+    ));
+  }|]
+
+tensor__nested_tensor_strides
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__nested_tensor_strides _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._nested_tensor_strides(
+    ));
+  }|]
+
+-- tensor__nested_tensor_offsets
+--   :: Ptr Tensor
+--   -> IO (Ptr IntArray)
+-- tensor__nested_tensor_offsets _obj =
+--   [C.throwBlock| std::vector<int64_t>* { return new std::vector<int64_t>((*$(at::Tensor* _obj))._nested_tensor_offsets(
+--     ).vec());
+--   }|]
+
+tensor_trunc
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_trunc _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).trunc(
+    ));
+  }|]
+
+tensor_trunc_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_trunc_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).trunc_(
+    ));
+  }|]
+
+tensor_fix
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_fix _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fix(
+    ));
+  }|]
+
+tensor_fix_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_fix_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fix_(
+    ));
+  }|]
+
+tensor_type_as_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_type_as_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).type_as(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_unsqueeze_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_unsqueeze_l _obj _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).unsqueeze(
+    $(int64_t _dim)));
+  }|]
+
+tensor_unsqueeze__l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_unsqueeze__l _obj _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).unsqueeze_(
+    $(int64_t _dim)));
+  }|]
+
+tensor_var_b
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_var_b _obj _unbiased =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).var(
+    $(bool _unbiased)));
+  }|]
+
+tensor_var_lbb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_var_lbb _obj _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).var(
+    *$(std::vector<int64_t>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_var_llb
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_var_llb _obj _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).var(
+    *$(std::vector<int64_t>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_var_Nbb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_var_Nbb _obj _dim _unbiased _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).var(
+    *$(std::vector<at::Dimname>* _dim)
+  , $(bool _unbiased)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_var_Nlb
+  :: Ptr Tensor
+  -> Ptr DimnameList
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_var_Nlb _obj _dim _correction _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).var(
+    *$(std::vector<at::Dimname>* _dim)
+  , $(int64_t _correction)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_view_as_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_view_as_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).view_as(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_where_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_where_tt _obj _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).where(
+    *$(at::Tensor* _self)
+  , *$(at::Tensor* _other)));
+  }|]
+
+tensor_where_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_where_ts _obj _self _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).where(
+    *$(at::Tensor* _self)
+  , *$(at::Scalar* _other)));
+  }|]
+
+tensor_norm_ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_norm_ss _obj _p _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).norm(
+    *$(at::Scalar* _p)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_norm_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_norm_s _obj _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).norm(
+    *$(at::Scalar* _p)));
+  }|]
+
+tensor_norm_slbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_norm_slbs _obj _p _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).norm(
+    *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_norm_slb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr IntArray
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_norm_slb _obj _p _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).norm(
+    *$(at::Scalar* _p)
+  , *$(std::vector<int64_t>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_norm_sNbs
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> CBool
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_norm_sNbs _obj _p _dim _keepdim _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).norm(
+    *$(at::Scalar* _p)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)
+  , $(at::ScalarType _dtype)));
+  }|]
+
+tensor_norm_sNb
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr DimnameList
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_norm_sNb _obj _p _dim _keepdim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).norm(
+    *$(at::Scalar* _p)
+  , *$(std::vector<at::Dimname>* _dim)
+  , $(bool _keepdim)));
+  }|]
+
+tensor_frexp
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_frexp _obj =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).frexp(
+    ));
+  }|]
+
+tensor_clone_M
+  :: Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_clone_M _obj _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).clone(
+    $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor_positive
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_positive _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).positive(
+    ));
+  }|]
+
+tensor_resize_as__tM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_resize_as__tM _obj _the_template _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).resize_as_(
+    *$(at::Tensor* _the_template)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor_resize_as_sparse__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_resize_as_sparse__t _obj _the_template =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).resize_as_sparse_(
+    *$(at::Tensor* _the_template)));
+  }|]
+
+tensor_zero_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_zero_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).zero_(
+    ));
+  }|]
+
+tensor_sub_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_sub_ts _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sub(
+    *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_sub__ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_sub__ts _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sub_(
+    *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_sub_ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_sub_ss _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sub(
+    *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_sub__ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_sub__ss _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sub_(
+    *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_subtract_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_subtract_ts _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).subtract(
+    *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_subtract__ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_subtract__ts _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).subtract_(
+    *$(at::Tensor* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_subtract_ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_subtract_ss _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).subtract(
+    *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_subtract__ss
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_subtract__ss _obj _other _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).subtract_(
+    *$(at::Scalar* _other)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_heaviside_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_heaviside_t _obj _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).heaviside(
+    *$(at::Tensor* _values)));
+  }|]
+
+tensor_heaviside__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_heaviside__t _obj _values =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).heaviside_(
+    *$(at::Tensor* _values)));
+  }|]
+
+tensor_addmm_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addmm_ttss _obj _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addmm(
+    *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_addmm__ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addmm__ttss _obj _mat1 _mat2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addmm_(
+    *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor__addmm_activation_ttssb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor__addmm_activation_ttssb _obj _mat1 _mat2 _beta _alpha _use_gelu =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._addmm_activation(
+    *$(at::Tensor* _mat1)
+  , *$(at::Tensor* _mat2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)
+  , $(bool _use_gelu)));
+  }|]
+
+tensor_sparse_resize__lll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_sparse_resize__lll _obj _size _sparse_dim _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sparse_resize_(
+    *$(std::vector<int64_t>* _size)
+  , $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)));
+  }|]
+
+tensor_sparse_resize_and_clear__lll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_sparse_resize_and_clear__lll _obj _size _sparse_dim _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sparse_resize_and_clear_(
+    *$(std::vector<int64_t>* _size)
+  , $(int64_t _sparse_dim)
+  , $(int64_t _dense_dim)));
+  }|]
+
+tensor_sparse_mask_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sparse_mask_t _obj _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sparse_mask(
+    *$(at::Tensor* _mask)));
+  }|]
+
+tensor_to_dense_s
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_to_dense_s _obj _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_dense(
+    $(at::ScalarType _dtype)));
+  }|]
+
+tensor__to_dense_s
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor__to_dense_s _obj _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._to_dense(
+    $(at::ScalarType _dtype)));
+  }|]
+
+tensor_sparse_dim
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_sparse_dim _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).sparse_dim(
+    );
+  }|]
+
+tensor__dimI
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor__dimI _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj))._dimI(
+    );
+  }|]
+
+tensor_dense_dim
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_dense_dim _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).dense_dim(
+    );
+  }|]
+
+tensor__dimV
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor__dimV _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj))._dimV(
+    );
+  }|]
+
+tensor__nnz
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor__nnz _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj))._nnz(
+    );
+  }|]
+
+tensor_coalesce
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_coalesce _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).coalesce(
+    ));
+  }|]
+
+tensor_is_coalesced
+  :: Ptr Tensor
+  -> IO (CBool)
+tensor_is_coalesced _obj =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_coalesced(
+    );
+  }|]
+
+tensor__indices
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__indices _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._indices(
+    ));
+  }|]
+
+tensor__values
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor__values _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._values(
+    ));
+  }|]
+
+tensor__coalesced__b
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor__coalesced__b _obj _coalesced =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._coalesced_(
+    $(bool _coalesced)));
+  }|]
+
+tensor_indices
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_indices _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).indices(
+    ));
+  }|]
+
+tensor_values
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_values _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).values(
+    ));
+  }|]
+
+tensor_crow_indices
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_crow_indices _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).crow_indices(
+    ));
+  }|]
+
+tensor_col_indices
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_col_indices _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).col_indices(
+    ));
+  }|]
+
+tensor_ccol_indices
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ccol_indices _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ccol_indices(
+    ));
+  }|]
+
+tensor_row_indices
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_row_indices _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).row_indices(
+    ));
+  }|]
+
+tensor_unbind_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr TensorList)
+tensor_unbind_l _obj _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).unbind(
+    $(int64_t _dim)));
+  }|]
+
+tensor_unbind_n
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> IO (Ptr TensorList)
+tensor_unbind_n _obj _dim =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).unbind(
+    *$(at::Dimname* _dim)));
+  }|]
+
+tensor_to_sparse_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_to_sparse_l _obj _sparse_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_sparse(
+    $(int64_t _sparse_dim)));
+  }|]
+
+tensor_to_sparse_Lll
+  :: Ptr Tensor
+  -> Layout
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_to_sparse_Lll _obj _layout _blocksize _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_sparse(
+    $(at::Layout _layout)
+  , *$(std::vector<int64_t>* _blocksize)
+  , $(int64_t _dense_dim)));
+  }|]
+
+tensor_to_sparse_csr_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_to_sparse_csr_l _obj _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_sparse_csr(
+    $(int64_t _dense_dim)));
+  }|]
+
+tensor_to_sparse_csc_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_to_sparse_csc_l _obj _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_sparse_csc(
+    $(int64_t _dense_dim)));
+  }|]
+
+tensor_to_sparse_bsr_ll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_to_sparse_bsr_ll _obj _blocksize _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_sparse_bsr(
+    *$(std::vector<int64_t>* _blocksize)
+  , $(int64_t _dense_dim)));
+  }|]
+
+tensor_to_sparse_bsc_ll
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_to_sparse_bsc_ll _obj _blocksize _dense_dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_sparse_bsc(
+    *$(std::vector<int64_t>* _blocksize)
+  , $(int64_t _dense_dim)));
+  }|]
+
+tensor_to_mkldnn_s
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_to_mkldnn_s _obj _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_mkldnn(
+    $(at::ScalarType _dtype)));
+  }|]
+
+tensor_dequantize
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_dequantize _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).dequantize(
+    ));
+  }|]
+
+tensor_q_scale
+  :: Ptr Tensor
+  -> IO (CDouble)
+tensor_q_scale _obj =
+  [C.throwBlock| double { return (*$(at::Tensor* _obj)).q_scale(
+    );
+  }|]
+
+tensor_q_zero_point
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_q_zero_point _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).q_zero_point(
+    );
+  }|]
+
+tensor_q_per_channel_scales
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_q_per_channel_scales _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).q_per_channel_scales(
+    ));
+  }|]
+
+tensor_q_per_channel_zero_points
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_q_per_channel_zero_points _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).q_per_channel_zero_points(
+    ));
+  }|]
+
+tensor_q_per_channel_axis
+  :: Ptr Tensor
+  -> IO (Int64)
+tensor_q_per_channel_axis _obj =
+  [C.throwBlock| int64_t { return (*$(at::Tensor* _obj)).q_per_channel_axis(
+    );
+  }|]
+
+tensor_int_repr
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_int_repr _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).int_repr(
+    ));
+  }|]
+
+tensor_qscheme
+  :: Ptr Tensor
+  -> IO (QScheme)
+tensor_qscheme _obj =
+  [C.throwBlock| at::QScheme { return (*$(at::Tensor* _obj)).qscheme(
+    );
+  }|]
+
+tensor__autocast_to_reduced_precision_bbss
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> ScalarType
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor__autocast_to_reduced_precision_bbss _obj _cuda_enabled _cpu_enabled _cuda_dtype _cpu_dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._autocast_to_reduced_precision(
+    $(bool _cuda_enabled)
+  , $(bool _cpu_enabled)
+  , $(at::ScalarType _cuda_dtype)
+  , $(at::ScalarType _cpu_dtype)));
+  }|]
+
+tensor__autocast_to_full_precision_bb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor__autocast_to_full_precision_bb _obj _cuda_enabled _cpu_enabled =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj))._autocast_to_full_precision(
+    $(bool _cuda_enabled)
+  , $(bool _cpu_enabled)));
+  }|]
+
+tensor_to_obbM
+  :: Ptr Tensor
+  -> Ptr TensorOptions
+  -> CBool
+  -> CBool
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_to_obbM _obj _options _non_blocking _copy _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to(
+    *$(at::TensorOptions* _options)
+  , $(bool _non_blocking)
+  , $(bool _copy)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor_to_DsbbM
+  :: Ptr Tensor
+  -> DeviceType
+  -> ScalarType
+  -> CBool
+  -> CBool
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_to_DsbbM _obj _device _dtype _non_blocking _copy _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to(
+    $(at::DeviceType _device)
+  , $(at::ScalarType _dtype)
+  , $(bool _non_blocking)
+  , $(bool _copy)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor_to_sbbM
+  :: Ptr Tensor
+  -> ScalarType
+  -> CBool
+  -> CBool
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_to_sbbM _obj _dtype _non_blocking _copy _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to(
+    $(at::ScalarType _dtype)
+  , $(bool _non_blocking)
+  , $(bool _copy)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor_to_tbbM
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> MemoryFormat
+  -> IO (Ptr Tensor)
+tensor_to_tbbM _obj _other _non_blocking _copy _memory_format =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to(
+    *$(at::Tensor* _other)
+  , $(bool _non_blocking)
+  , $(bool _copy)
+  , $(at::MemoryFormat _memory_format)));
+  }|]
+
+tensor_item
+  :: Ptr Tensor
+  -> IO (Ptr Scalar)
+tensor_item _obj =
+  [C.throwBlock| at::Scalar* { return new at::Scalar((*$(at::Tensor* _obj)).item(
+    ));
+  }|]
+
+tensor_set__S
+  :: Ptr Tensor
+  -> Ptr Storage
+  -> IO (Ptr Tensor)
+tensor_set__S _obj _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).set_(
+    *$(at::Storage* _source)));
+  }|]
+
+tensor_set__Slll
+  :: Ptr Tensor
+  -> Ptr Storage
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_set__Slll _obj _source _storage_offset _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).set_(
+    *$(at::Storage* _source)
+  , $(int64_t _storage_offset)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+tensor_set__tlll
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> Ptr IntArray
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_set__tlll _obj _source _storage_offset _size _stride =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).set_(
+    *$(at::Tensor* _source)
+  , $(int64_t _storage_offset)
+  , *$(std::vector<int64_t>* _size)
+  , *$(std::vector<int64_t>* _stride)));
+  }|]
+
+tensor_set__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_set__t _obj _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).set_(
+    *$(at::Tensor* _source)));
+  }|]
+
+tensor_set_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_set_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).set_(
+    ));
+  }|]
+
+tensor_is_set_to_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+tensor_is_set_to_t _obj _tensor =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).is_set_to(
+    *$(at::Tensor* _tensor));
+  }|]
+
+tensor_masked_fill__ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_masked_fill__ts _obj _mask _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).masked_fill_(
+    *$(at::Tensor* _mask)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_masked_fill_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_masked_fill_ts _obj _mask _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).masked_fill(
+    *$(at::Tensor* _mask)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_masked_fill__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_masked_fill__tt _obj _mask _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).masked_fill_(
+    *$(at::Tensor* _mask)
+  , *$(at::Tensor* _value)));
+  }|]
+
+tensor_masked_fill_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_masked_fill_tt _obj _mask _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).masked_fill(
+    *$(at::Tensor* _mask)
+  , *$(at::Tensor* _value)));
+  }|]
+
+tensor_masked_scatter__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_masked_scatter__tt _obj _mask _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).masked_scatter_(
+    *$(at::Tensor* _mask)
+  , *$(at::Tensor* _source)));
+  }|]
+
+tensor_masked_scatter_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_masked_scatter_tt _obj _mask _source =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).masked_scatter(
+    *$(at::Tensor* _mask)
+  , *$(at::Tensor* _source)));
+  }|]
+
+tensor_view_l
+  :: Ptr Tensor
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_view_l _obj _size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).view(
+    *$(std::vector<int64_t>* _size)));
+  }|]
+
+tensor_view_s
+  :: Ptr Tensor
+  -> ScalarType
+  -> IO (Ptr Tensor)
+tensor_view_s _obj _dtype =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).view(
+    $(at::ScalarType _dtype)));
+  }|]
+
+tensor_put__ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_put__ttb _obj _index _source _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).put_(
+    *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , $(bool _accumulate)));
+  }|]
+
+tensor_put_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_put_ttb _obj _index _source _accumulate =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).put(
+    *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , $(bool _accumulate)));
+  }|]
+
+tensor_index_add__ltts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_index_add__ltts _obj _dim _index _source _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_add_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_index_add_ltts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_index_add_ltts _obj _dim _index _source _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_add(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_index_add_ntts
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_index_add_ntts _obj _dim _index _source _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_add(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_index_reduce__lttsb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_index_reduce__lttsb _obj _dim _index _source _reduce _include_self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_reduce_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(std::string* _reduce)
+  , $(bool _include_self)));
+  }|]
+
+tensor_index_reduce_lttsb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_index_reduce_lttsb _obj _dim _index _source _reduce _include_self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_reduce(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _source)
+  , *$(std::string* _reduce)
+  , $(bool _include_self)));
+  }|]
+
+tensor_index_fill__lts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_index_fill__lts _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_fill_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_index_fill_lts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_index_fill_lts _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_fill(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_index_fill__ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_fill__ltt _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_fill_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _value)));
+  }|]
+
+tensor_index_fill_ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_fill_ltt _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_fill(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _value)));
+  }|]
+
+tensor_index_fill__nts
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_index_fill__nts _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_fill_(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_index_fill__ntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_fill__ntt _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_fill_(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _value)));
+  }|]
+
+tensor_index_fill_nts
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_index_fill_nts _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_fill(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_index_fill_ntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_fill_ntt _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_fill(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _value)));
+  }|]
+
+tensor_scatter_ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_scatter_ltt _obj _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+tensor_scatter__ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_scatter__ltt _obj _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+tensor_scatter_lts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_scatter_lts _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_scatter__lts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_scatter__lts _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_scatter_ltts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_scatter_ltts _obj _dim _index _src _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)));
+  }|]
+
+tensor_scatter__ltts
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_scatter__ltts _obj _dim _index _src _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)));
+  }|]
+
+tensor_scatter_ltss
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_scatter_ltss _obj _dim _index _value _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)
+  , *$(std::string* _reduce)));
+  }|]
+
+tensor_scatter__ltss
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_scatter__ltss _obj _dim _index _value _reduce =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)
+  , *$(std::string* _reduce)));
+  }|]
+
+tensor_scatter_ntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_scatter_ntt _obj _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+tensor_scatter_nts
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_scatter_nts _obj _dim _index _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_scatter_add_ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_scatter_add_ltt _obj _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_add(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+tensor_scatter_add__ltt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_scatter_add__ltt _obj _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_add_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+tensor_scatter_add_ntt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_scatter_add_ntt _obj _dim _index _src =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_add(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)));
+  }|]
+
+tensor_scatter_reduce_lttsb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_scatter_reduce_lttsb _obj _dim _index _src _reduce _include_self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_reduce(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)
+  , $(bool _include_self)));
+  }|]
+
+tensor_scatter_reduce__lttsb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr StdString
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_scatter_reduce__lttsb _obj _dim _index _src _reduce _include_self =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).scatter_reduce_(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , *$(at::Tensor* _src)
+  , *$(std::string* _reduce)
+  , $(bool _include_self)));
+  }|]
+
+tensor_eq__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_eq__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).eq_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_eq__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_eq__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).eq_(
+    *$(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
+  -> IO (Ptr Tensor)
+tensor___and___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__and__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___and___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___and___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__and__(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor___iand___s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor___iand___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__iand__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___iand___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___iand___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__iand__(
+    *$(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)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor3.hs b/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor3.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Tensor/Tensor3.hs
@@ -0,0 +1,2073 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Tensor.Tensor3 where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/Tensor.h>"
+C.include "<ATen/Functions.h>"
+C.include "<ATen/TensorOperators.h>"
+C.include "<vector>"
+
+
+
+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
+  -> IO (Ptr Tensor)
+tensor___or___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__or__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___or___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___or___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__or__(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor___ior___s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor___ior___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__ior__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___ior___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___ior___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__ior__(
+    *$(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
+  -> IO (Ptr Tensor)
+tensor___xor___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__xor__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___xor___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___xor___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__xor__(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor___ixor___s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor___ixor___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__ixor__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___ixor___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___ixor___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__ixor__(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor___lshift___s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor___lshift___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__lshift__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___lshift___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___lshift___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__lshift__(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor___ilshift___s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor___ilshift___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__ilshift__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___ilshift___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___ilshift___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__ilshift__(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_left_shift_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_left_shift_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_left_shift(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_left_shift__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_left_shift__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_left_shift_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_left_shift_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_left_shift_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_left_shift(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_bitwise_left_shift__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_left_shift__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_left_shift_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___rshift___s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor___rshift___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__rshift__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___rshift___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___rshift___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__rshift__(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor___irshift___s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor___irshift___s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__irshift__(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor___irshift___t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor___irshift___t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).__irshift__(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_right_shift_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_right_shift_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_right_shift(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_right_shift__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_bitwise_right_shift__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_right_shift_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_bitwise_right_shift_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_right_shift_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_right_shift(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_bitwise_right_shift__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_bitwise_right_shift__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).bitwise_right_shift_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_tril__l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_tril__l _obj _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).tril_(
+    $(int64_t _diagonal)));
+  }|]
+
+tensor_triu__l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_triu__l _obj _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).triu_(
+    $(int64_t _diagonal)));
+  }|]
+
+tensor_digamma_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_digamma_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).digamma_(
+    ));
+  }|]
+
+tensor_lerp__ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_lerp__ts _obj _end _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lerp_(
+    *$(at::Tensor* _end)
+  , *$(at::Scalar* _weight)));
+  }|]
+
+tensor_lerp__tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lerp__tt _obj _end _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lerp_(
+    *$(at::Tensor* _end)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+tensor_addbmm__ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addbmm__ttss _obj _batch1 _batch2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addbmm_(
+    *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_addbmm_ttss
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addbmm_ttss _obj _batch1 _batch2 _beta _alpha =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addbmm(
+    *$(at::Tensor* _batch1)
+  , *$(at::Tensor* _batch2)
+  , *$(at::Scalar* _beta)
+  , *$(at::Scalar* _alpha)));
+  }|]
+
+tensor_random__llG
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_random__llG _obj _from _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).random_(
+    $(int64_t _from)
+  , $(int64_t _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_random__lG
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_random__lG _obj _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).random_(
+    $(int64_t _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_random__G
+  :: Ptr Tensor
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_random__G _obj _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).random_(
+    *$(at::Generator* _generator)));
+  }|]
+
+tensor_uniform__ddG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_uniform__ddG _obj _from _to _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).uniform_(
+    $(double _from)
+  , $(double _to)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_cauchy__ddG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_cauchy__ddG _obj _median _sigma _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cauchy_(
+    $(double _median)
+  , $(double _sigma)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_log_normal__ddG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_log_normal__ddG _obj _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).log_normal_(
+    $(double _mean)
+  , $(double _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_exponential__dG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_exponential__dG _obj _lambd _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).exponential_(
+    $(double _lambd)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_geometric__dG
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_geometric__dG _obj _p _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).geometric_(
+    $(double _p)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_diag_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_diag_l _obj _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).diag(
+    $(int64_t _diagonal)));
+  }|]
+
+tensor_cross_tl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_cross_tl _obj _other _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cross(
+    *$(at::Tensor* _other)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_triu_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_triu_l _obj _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).triu(
+    $(int64_t _diagonal)));
+  }|]
+
+tensor_tril_l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_tril_l _obj _diagonal =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).tril(
+    $(int64_t _diagonal)));
+  }|]
+
+tensor_trace
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_trace _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).trace(
+    ));
+  }|]
+
+tensor_ne_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_ne_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ne(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_ne_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ne_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ne(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_ne__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_ne__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ne_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_ne__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ne__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ne_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_not_equal_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_not_equal_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).not_equal(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_not_equal_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_not_equal_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).not_equal(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_not_equal__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_not_equal__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).not_equal_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_not_equal__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_not_equal__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).not_equal_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_eq_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_eq_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).eq(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_eq_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_eq_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).eq(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_ge_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_ge_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ge(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_ge_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ge_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ge(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_ge__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_ge__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ge_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_ge__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ge__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ge_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_greater_equal_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_greater_equal_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).greater_equal(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_greater_equal_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_greater_equal_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).greater_equal(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_greater_equal__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_greater_equal__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).greater_equal_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_greater_equal__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_greater_equal__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).greater_equal_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_le_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_le_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).le(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_le_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_le_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).le(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_le__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_le__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).le_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_le__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_le__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).le_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_less_equal_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_less_equal_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).less_equal(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_less_equal_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_less_equal_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).less_equal(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_less_equal__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_less_equal__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).less_equal_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_less_equal__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_less_equal__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).less_equal_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_gt_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_gt_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).gt(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_gt_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_gt_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).gt(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_gt__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_gt__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).gt_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_gt__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_gt__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).gt_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_greater_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_greater_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).greater(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_greater_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_greater_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).greater(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_greater__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_greater__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).greater_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_greater__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_greater__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).greater_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_lt_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_lt_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lt(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_lt_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lt_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lt(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_lt__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_lt__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lt_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_lt__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lt__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lt_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_less_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_less_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).less(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_less_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_less_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).less(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_less__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_less__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).less_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_less__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_less__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).less_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_take_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_take_t _obj _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).take(
+    *$(at::Tensor* _index)));
+  }|]
+
+tensor_take_along_dim_tl
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_take_along_dim_tl _obj _indices _dim =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).take_along_dim(
+    *$(at::Tensor* _indices)
+  , $(int64_t _dim)));
+  }|]
+
+tensor_index_select_lt
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_select_lt _obj _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_select(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+tensor_index_select_nt
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_index_select_nt _obj _dim _index =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_select(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)));
+  }|]
+
+tensor_masked_select_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_masked_select_t _obj _mask =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).masked_select(
+    *$(at::Tensor* _mask)));
+  }|]
+
+tensor_nonzero
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_nonzero _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nonzero(
+    ));
+  }|]
+
+tensor_nonzero_numpy
+  :: Ptr Tensor
+  -> IO (Ptr TensorList)
+tensor_nonzero_numpy _obj =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>((*$(at::Tensor* _obj)).nonzero_numpy(
+    ));
+  }|]
+
+tensor_argwhere
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_argwhere _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).argwhere(
+    ));
+  }|]
+
+tensor_gather_ltb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_gather_ltb _obj _dim _index _sparse_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).gather(
+    $(int64_t _dim)
+  , *$(at::Tensor* _index)
+  , $(bool _sparse_grad)));
+  }|]
+
+tensor_gather_ntb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_gather_ntb _obj _dim _index _sparse_grad =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).gather(
+    *$(at::Dimname* _dim)
+  , *$(at::Tensor* _index)
+  , $(bool _sparse_grad)));
+  }|]
+
+tensor_addcmul_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addcmul_tts _obj _tensor1 _tensor2 _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addcmul(
+    *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_addcmul__tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addcmul__tts _obj _tensor1 _tensor2 _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addcmul_(
+    *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_addcdiv_tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addcdiv_tts _obj _tensor1 _tensor2 _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addcdiv(
+    *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_addcdiv__tts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_addcdiv__tts _obj _tensor1 _tensor2 _value =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).addcdiv_(
+    *$(at::Tensor* _tensor1)
+  , *$(at::Tensor* _tensor2)
+  , *$(at::Scalar* _value)));
+  }|]
+
+tensor_triangular_solve_tbbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_triangular_solve_tbbb _obj _A _upper _transpose _unitriangular =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).triangular_solve(
+    *$(at::Tensor* _A)
+  , $(bool _upper)
+  , $(bool _transpose)
+  , $(bool _unitriangular)));
+  }|]
+
+tensor_svd_bb
+  :: Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
+tensor_svd_bb _obj _some _compute_uv =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).svd(
+    $(bool _some)
+  , $(bool _compute_uv)));
+  }|]
+
+tensor_swapaxes_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_swapaxes_ll _obj _axis0 _axis1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).swapaxes(
+    $(int64_t _axis0)
+  , $(int64_t _axis1)));
+  }|]
+
+tensor_swapaxes__ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_swapaxes__ll _obj _axis0 _axis1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).swapaxes_(
+    $(int64_t _axis0)
+  , $(int64_t _axis1)));
+  }|]
+
+tensor_swapdims_ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_swapdims_ll _obj _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).swapdims(
+    $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+tensor_swapdims__ll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_swapdims__ll _obj _dim0 _dim1 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).swapdims_(
+    $(int64_t _dim0)
+  , $(int64_t _dim1)));
+  }|]
+
+tensor_cholesky_b
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_cholesky_b _obj _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cholesky(
+    $(bool _upper)));
+  }|]
+
+tensor_cholesky_solve_tb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_cholesky_solve_tb _obj _input2 _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cholesky_solve(
+    *$(at::Tensor* _input2)
+  , $(bool _upper)));
+  }|]
+
+tensor_cholesky_inverse_b
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_cholesky_inverse_b _obj _upper =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).cholesky_inverse(
+    $(bool _upper)));
+  }|]
+
+tensor_qr_b
+  :: Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_qr_b _obj _some =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).qr(
+    $(bool _some)));
+  }|]
+
+tensor_geqrf
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_geqrf _obj =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).geqrf(
+    ));
+  }|]
+
+tensor_orgqr_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_orgqr_t _obj _input2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).orgqr(
+    *$(at::Tensor* _input2)));
+  }|]
+
+tensor_ormqr_ttbb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_ormqr_ttbb _obj _input2 _input3 _left _transpose =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ormqr(
+    *$(at::Tensor* _input2)
+  , *$(at::Tensor* _input3)
+  , $(bool _left)
+  , $(bool _transpose)));
+  }|]
+
+tensor_lu_solve_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lu_solve_tt _obj _LU_data _LU_pivots =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lu_solve(
+    *$(at::Tensor* _LU_data)
+  , *$(at::Tensor* _LU_pivots)));
+  }|]
+
+tensor_multinomial_lbG
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_multinomial_lbG _obj _num_samples _replacement _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).multinomial(
+    $(int64_t _num_samples)
+  , $(bool _replacement)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_lgamma_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lgamma_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lgamma_(
+    ));
+  }|]
+
+tensor_lgamma
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lgamma _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lgamma(
+    ));
+  }|]
+
+tensor_digamma
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_digamma _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).digamma(
+    ));
+  }|]
+
+tensor_polygamma__l
+  :: Ptr Tensor
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_polygamma__l _obj _n =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).polygamma_(
+    $(int64_t _n)));
+  }|]
+
+tensor_erfinv
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_erfinv _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).erfinv(
+    ));
+  }|]
+
+tensor_erfinv_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_erfinv_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).erfinv_(
+    ));
+  }|]
+
+tensor_i0
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_i0 _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).i0(
+    ));
+  }|]
+
+tensor_i0_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_i0_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).i0_(
+    ));
+  }|]
+
+tensor_sign
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sign _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sign(
+    ));
+  }|]
+
+tensor_sign_
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_sign_ _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).sign_(
+    ));
+  }|]
+
+tensor_signbit
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_signbit _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).signbit(
+    ));
+  }|]
+
+tensor_dist_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_dist_ts _obj _other _p =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).dist(
+    *$(at::Tensor* _other)
+  , *$(at::Scalar* _p)));
+  }|]
+
+tensor_atan2__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_atan2__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).atan2_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_atan2_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_atan2_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).atan2(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_arctan2_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arctan2_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arctan2(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_arctan2__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_arctan2__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).arctan2_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_lerp_ts
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_lerp_ts _obj _end _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lerp(
+    *$(at::Tensor* _end)
+  , *$(at::Scalar* _weight)));
+  }|]
+
+tensor_lerp_tt
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_lerp_tt _obj _end _weight =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).lerp(
+    *$(at::Tensor* _end)
+  , *$(at::Tensor* _weight)));
+  }|]
+
+tensor_histc_lss
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr Scalar
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_histc_lss _obj _bins _min _max =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).histc(
+    $(int64_t _bins)
+  , *$(at::Scalar* _min)
+  , *$(at::Scalar* _max)));
+  }|]
+
+tensor_histogram_ttb
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_histogram_ttb _obj _bins _weight _density =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).histogram(
+    *$(at::Tensor* _bins)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+tensor_histogram_latb
+  :: Ptr Tensor
+  -> Int64
+  -> Ptr (StdVector CDouble)
+  -> Ptr Tensor
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_histogram_latb _obj _bins _range _weight _density =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).histogram(
+    $(int64_t _bins)
+  , *$(std::vector<double>* _range)
+  , *$(at::Tensor* _weight)
+  , $(bool _density)));
+  }|]
+
+tensor_fmod_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_fmod_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fmod(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_fmod__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_fmod__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fmod_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_fmod_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_fmod_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fmod(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_fmod__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_fmod__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fmod_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_hypot_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_hypot_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).hypot(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_hypot__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_hypot__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).hypot_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_igamma_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_igamma_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).igamma(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_igamma__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_igamma__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).igamma_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_igammac_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_igammac_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).igammac(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_igammac__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_igammac__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).igammac_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_nextafter_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_nextafter_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nextafter(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_nextafter__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_nextafter__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nextafter_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_remainder_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_remainder_s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).remainder(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_remainder__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_remainder__s _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).remainder_(
+    *$(at::Scalar* _other)));
+  }|]
+
+tensor_remainder_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_remainder_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).remainder(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_remainder__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_remainder__t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).remainder_(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_min
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_min _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).min(
+    ));
+  }|]
+
+tensor_fmin_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_fmin_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fmin(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_max
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_max _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).max(
+    ));
+  }|]
+
+tensor_fmax_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_fmax_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).fmax(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_maximum_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_maximum_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).maximum(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_max_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_max_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).max(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_minimum_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_minimum_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).minimum(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_min_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_min_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).min(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_quantile_tlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_quantile_tlbs _obj _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).quantile(
+    *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+tensor_quantile_dlbs
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_quantile_dlbs _obj _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).quantile(
+    $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+tensor_nanquantile_tlbs
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_nanquantile_tlbs _obj _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nanquantile(
+    *$(at::Tensor* _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+tensor_nanquantile_dlbs
+  :: Ptr Tensor
+  -> CDouble
+  -> Int64
+  -> CBool
+  -> Ptr StdString
+  -> IO (Ptr Tensor)
+tensor_nanquantile_dlbs _obj _q _dim _keepdim _interpolation =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).nanquantile(
+    $(double _q)
+  , $(int64_t _dim)
+  , $(bool _keepdim)
+  , *$(std::string* _interpolation)));
+  }|]
+
+tensor_sort_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_sort_lb _obj _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).sort(
+    $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+tensor_sort_blb
+  :: Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_sort_blb _obj _stable _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).sort(
+    $(bool _stable)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+tensor_sort_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_sort_nb _obj _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).sort(
+    *$(at::Dimname* _dim)
+  , $(bool _descending)));
+  }|]
+
+tensor_sort_bnb
+  :: Ptr Tensor
+  -> CBool
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_sort_bnb _obj _stable _dim _descending =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).sort(
+    $(bool _stable)
+  , *$(at::Dimname* _dim)
+  , $(bool _descending)));
+  }|]
+
+tensor_msort
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_msort _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).msort(
+    ));
+  }|]
+
+tensor_argsort_lb
+  :: Ptr Tensor
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_argsort_lb _obj _dim _descending =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).argsort(
+    $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+tensor_argsort_blb
+  :: Ptr Tensor
+  -> CBool
+  -> Int64
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_argsort_blb _obj _stable _dim _descending =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).argsort(
+    $(bool _stable)
+  , $(int64_t _dim)
+  , $(bool _descending)));
+  }|]
+
+tensor_argsort_nb
+  :: Ptr Tensor
+  -> Ptr Dimname
+  -> CBool
+  -> IO (Ptr Tensor)
+tensor_argsort_nb _obj _dim _descending =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).argsort(
+    *$(at::Dimname* _dim)
+  , $(bool _descending)));
+  }|]
+
+tensor_topk_llbb
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> CBool
+  -> CBool
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_topk_llbb _obj _k _dim _largest _sorted =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).topk(
+    $(int64_t _k)
+  , $(int64_t _dim)
+  , $(bool _largest)
+  , $(bool _sorted)));
+  }|]
+
+tensor_all
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_all _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).all(
+    ));
+  }|]
+
+tensor_any
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_any _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).any(
+    ));
+  }|]
+
+tensor_renorm_sls
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Int64
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_renorm_sls _obj _p _dim _maxnorm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).renorm(
+    *$(at::Scalar* _p)
+  , $(int64_t _dim)
+  , *$(at::Scalar* _maxnorm)));
+  }|]
+
+tensor_renorm__sls
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> Int64
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_renorm__sls _obj _p _dim _maxnorm =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).renorm_(
+    *$(at::Scalar* _p)
+  , $(int64_t _dim)
+  , *$(at::Scalar* _maxnorm)));
+  }|]
+
+tensor_unfold_lll
+  :: Ptr Tensor
+  -> Int64
+  -> Int64
+  -> Int64
+  -> IO (Ptr Tensor)
+tensor_unfold_lll _obj _dimension _size _step =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).unfold(
+    $(int64_t _dimension)
+  , $(int64_t _size)
+  , $(int64_t _step)));
+  }|]
+
+tensor_equal_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (CBool)
+tensor_equal_t _obj _other =
+  [C.throwBlock| bool { return (*$(at::Tensor* _obj)).equal(
+    *$(at::Tensor* _other));
+  }|]
+
+tensor_pow_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_pow_t _obj _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).pow(
+    *$(at::Tensor* _exponent)));
+  }|]
+
+tensor_pow_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_pow_s _obj _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).pow(
+    *$(at::Scalar* _exponent)));
+  }|]
+
+tensor_pow__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_pow__s _obj _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).pow_(
+    *$(at::Scalar* _exponent)));
+  }|]
+
+tensor_pow__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_pow__t _obj _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).pow_(
+    *$(at::Tensor* _exponent)));
+  }|]
+
+tensor_float_power_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_float_power_t _obj _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).float_power(
+    *$(at::Tensor* _exponent)));
+  }|]
+
+tensor_float_power_s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_float_power_s _obj _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).float_power(
+    *$(at::Scalar* _exponent)));
+  }|]
+
+tensor_float_power__s
+  :: Ptr Tensor
+  -> Ptr Scalar
+  -> IO (Ptr Tensor)
+tensor_float_power__s _obj _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).float_power_(
+    *$(at::Scalar* _exponent)));
+  }|]
+
+tensor_float_power__t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_float_power__t _obj _exponent =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).float_power_(
+    *$(at::Tensor* _exponent)));
+  }|]
+
+tensor_normal__ddG
+  :: Ptr Tensor
+  -> CDouble
+  -> CDouble
+  -> Ptr Generator
+  -> IO (Ptr Tensor)
+tensor_normal__ddG _obj _mean _std _generator =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).normal_(
+    $(double _mean)
+  , $(double _std)
+  , *$(at::Generator* _generator)));
+  }|]
+
+tensor_alias
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_alias _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).alias(
+    ));
+  }|]
+
+tensor_isfinite
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_isfinite _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).isfinite(
+    ));
+  }|]
+
+tensor_isinf
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_isinf _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).isinf(
+    ));
+  }|]
+
+tensor_record_stream_s
+  :: Ptr Tensor
+  -> Ptr Stream
+  -> IO (())
+tensor_record_stream_s _obj _s =
+  [C.throwBlock| void {  (*$(at::Tensor* _obj)).record_stream(
+    *$(c10::Stream* _s));
+  }|]
+
+tensor_isposinf
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_isposinf _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).isposinf(
+    ));
+  }|]
+
+tensor_isneginf
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_isneginf _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).isneginf(
+    ));
+  }|]
+
+tensor_det
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_det _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).det(
+    ));
+  }|]
+
+tensor_slogdet
+  :: Ptr Tensor
+  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
+tensor_slogdet _obj =
+  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>((*$(at::Tensor* _obj)).slogdet(
+    ));
+  }|]
+
+tensor_logdet
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_logdet _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).logdet(
+    ));
+  }|]
+
+tensor_inverse
+  :: Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_inverse _obj =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).inverse(
+    ));
+  }|]
+
+tensor_inner_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_inner_t _obj _other =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).inner(
+    *$(at::Tensor* _other)));
+  }|]
+
+tensor_outer_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_outer_t _obj _vec2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).outer(
+    *$(at::Tensor* _vec2)));
+  }|]
+
+tensor_ger_t
+  :: Ptr Tensor
+  -> Ptr Tensor
+  -> IO (Ptr Tensor)
+tensor_ger_t _obj _vec2 =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).ger(
+    *$(at::Tensor* _vec2)));
+  }|]
+
+tensor_to_padded_tensor_dl
+  :: Ptr Tensor
+  -> CDouble
+  -> Ptr IntArray
+  -> IO (Ptr Tensor)
+tensor_to_padded_tensor_dl _obj _padding _output_size =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).to_padded_tensor(
+    $(double _padding)
+  , *$(std::vector<int64_t>* _output_size)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/TensorIndex.hs b/src/Torch/Internal/Unmanaged/Type/TensorIndex.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/TensorIndex.hs
@@ -0,0 +1,65 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.TensorIndex where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/TensorIndexing.h>"
+C.include "<vector>"
+
+newTensorIndexList :: IO (Ptr (StdVector TensorIndex))
+newTensorIndexList = [C.throwBlock| std::vector<at::indexing::TensorIndex>* { return new std::vector<at::indexing::TensorIndex>(); }|]
+
+newTensorIndexWithInt :: CInt -> IO (Ptr TensorIndex)
+newTensorIndexWithInt value = [C.throwBlock| at::indexing::TensorIndex* { return new at::indexing::TensorIndex($(int value)); }|]
+
+newTensorIndexWithBool :: CBool -> IO (Ptr TensorIndex)
+newTensorIndexWithBool value = [C.throwBlock| at::indexing::TensorIndex* { return new at::indexing::TensorIndex((bool)$(bool value)); }|]
+
+newTensorIndexWithSlice :: CInt -> CInt -> CInt -> IO (Ptr TensorIndex)
+newTensorIndexWithSlice start stop step = [C.throwBlock| at::indexing::TensorIndex* { return new at::indexing::TensorIndex(at::indexing::Slice($(int start),$(int stop),$(int step))); }|]
+
+newTensorIndexWithTensor :: Ptr Tensor -> IO (Ptr TensorIndex)
+newTensorIndexWithTensor value = [C.throwBlock| at::indexing::TensorIndex* { return new at::indexing::TensorIndex(*$(at::Tensor* value)); }|]
+
+newTensorIndexWithEllipsis :: IO (Ptr TensorIndex)
+newTensorIndexWithEllipsis = [C.throwBlock| at::indexing::TensorIndex* { return new at::indexing::TensorIndex("..."); }|]
+
+newTensorIndexWithNone :: IO (Ptr TensorIndex)
+newTensorIndexWithNone = [C.throwBlock| at::indexing::TensorIndex* { return new at::indexing::TensorIndex(at::indexing::None); }|]
+
+
+tensorIndexList_empty :: Ptr (StdVector TensorIndex) -> IO (CBool)
+tensorIndexList_empty _obj = [C.throwBlock| bool { return (*$(std::vector<at::indexing::TensorIndex>* _obj)).empty(); }|]
+
+tensorIndexList_size :: Ptr (StdVector TensorIndex) -> IO (CSize)
+tensorIndexList_size _obj = [C.throwBlock| size_t { return (*$(std::vector<at::indexing::TensorIndex>* _obj)).size(); }|]
+
+tensorIndexList_push_back :: Ptr (StdVector TensorIndex) -> Ptr TensorIndex -> IO ()
+tensorIndexList_push_back _obj _v = [C.throwBlock| void {  (*$(std::vector<at::indexing::TensorIndex>* _obj)).push_back(*$(at::indexing::TensorIndex* _v)); }|]
+
+index :: Ptr Tensor -> Ptr (StdVector TensorIndex) -> IO (Ptr Tensor)
+index _obj idx = [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index(*$(std::vector<at::indexing::TensorIndex>* idx))); } |]
+
+index_put_ :: Ptr Tensor -> Ptr (StdVector TensorIndex) -> Ptr Tensor -> IO (Ptr Tensor)
+index_put_ _obj idx value = [C.throwBlock| at::Tensor* { return new at::Tensor((*$(at::Tensor* _obj)).index_put_(*$(std::vector<at::indexing::TensorIndex>* idx),*$(at::Tensor * value))); } |]
diff --git a/src/Torch/Internal/Unmanaged/Type/TensorList.hs b/src/Torch/Internal/Unmanaged/Type/TensorList.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/TensorList.hs
@@ -0,0 +1,73 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.TensorList where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/Tensor.h>"
+C.include "<vector>"
+
+
+
+newTensorList
+  :: IO (Ptr TensorList)
+newTensorList  =
+  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(
+    );
+  }|]
+
+tensorList_empty
+  :: Ptr TensorList
+  -> IO (CBool)
+tensorList_empty _obj =
+  [C.throwBlock| bool { return (*$(std::vector<at::Tensor>* _obj)).empty(
+    );
+  }|]
+
+tensorList_size
+  :: Ptr TensorList
+  -> IO (CSize)
+tensorList_size _obj =
+  [C.throwBlock| size_t { return (*$(std::vector<at::Tensor>* _obj)).size(
+    );
+  }|]
+
+tensorList_at_s
+  :: Ptr TensorList
+  -> CSize
+  -> IO (Ptr Tensor)
+tensorList_at_s _obj _s =
+  [C.throwBlock| at::Tensor* { return new at::Tensor((*$(std::vector<at::Tensor>* _obj)).at(
+    $(size_t _s)));
+  }|]
+
+tensorList_push_back_t
+  :: Ptr TensorList
+  -> Ptr Tensor
+  -> IO (())
+tensorList_push_back_t _obj _v =
+  [C.throwBlock| void {  (*$(std::vector<at::Tensor>* _obj)).push_back(
+    *$(at::Tensor* _v));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/TensorOptions.hs b/src/Torch/Internal/Unmanaged/Type/TensorOptions.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/TensorOptions.hs
@@ -0,0 +1,197 @@
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.TensorOptions where
+
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+
+
+C.include "<ATen/TensorOptions.h>"
+C.include "<vector>"
+
+
+
+newTensorOptions_s
+  :: ScalarType
+  -> IO (Ptr TensorOptions)
+newTensorOptions_s _d =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions(
+    $(at::ScalarType _d));
+  }|]
+
+tensorOptions_device_D
+  :: Ptr TensorOptions
+  -> DeviceType
+  -> IO (Ptr TensorOptions)
+tensorOptions_device_D _obj _device =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions((*$(at::TensorOptions* _obj)).device(
+    $(at::DeviceType _device)));
+  }|]
+
+tensorOptions_device_index_s
+  :: Ptr TensorOptions
+  -> Int16
+  -> IO (Ptr TensorOptions)
+tensorOptions_device_index_s _obj _device_index =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions((*$(at::TensorOptions* _obj)).device_index(
+    $(int16_t _device_index)));
+  }|]
+
+tensorOptions_dtype_s
+  :: Ptr TensorOptions
+  -> ScalarType
+  -> IO (Ptr TensorOptions)
+tensorOptions_dtype_s _obj _dtype =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions((*$(at::TensorOptions* _obj)).dtype(
+    $(at::ScalarType _dtype)));
+  }|]
+
+tensorOptions_dtype
+  :: Ptr TensorOptions
+  -> IO (Ptr TensorOptions)
+tensorOptions_dtype _obj =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions((*$(at::TensorOptions* _obj)).dtype(
+    ));
+  }|]
+
+tensorOptions_layout_L
+  :: Ptr TensorOptions
+  -> Layout
+  -> IO (Ptr TensorOptions)
+tensorOptions_layout_L _obj _layout =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions((*$(at::TensorOptions* _obj)).layout(
+    $(at::Layout _layout)));
+  }|]
+
+tensorOptions_requires_grad_b
+  :: Ptr TensorOptions
+  -> CBool
+  -> IO (Ptr TensorOptions)
+tensorOptions_requires_grad_b _obj _requires_grad =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions((*$(at::TensorOptions* _obj)).requires_grad(
+    $(bool _requires_grad)));
+  }|]
+
+tensorOptions_has_device
+  :: Ptr TensorOptions
+  -> IO (CBool)
+tensorOptions_has_device _obj =
+  [C.throwBlock| bool { return (*$(at::TensorOptions* _obj)).has_device(
+    );
+  }|]
+
+tensorOptions_device_index
+  :: Ptr TensorOptions
+  -> IO (Int32)
+tensorOptions_device_index _obj =
+  [C.throwBlock| int32_t { return (*$(at::TensorOptions* _obj)).device_index(
+    );
+  }|]
+
+tensorOptions_has_dtype
+  :: Ptr TensorOptions
+  -> IO (CBool)
+tensorOptions_has_dtype _obj =
+  [C.throwBlock| bool { return (*$(at::TensorOptions* _obj)).has_dtype(
+    );
+  }|]
+
+tensorOptions_layout
+  :: Ptr TensorOptions
+  -> IO (Layout)
+tensorOptions_layout _obj =
+  [C.throwBlock| at::Layout { return (*$(at::TensorOptions* _obj)).layout(
+    );
+  }|]
+
+tensorOptions_has_layout
+  :: Ptr TensorOptions
+  -> IO (CBool)
+tensorOptions_has_layout _obj =
+  [C.throwBlock| bool { return (*$(at::TensorOptions* _obj)).has_layout(
+    );
+  }|]
+
+tensorOptions_requires_grad
+  :: Ptr TensorOptions
+  -> IO (CBool)
+tensorOptions_requires_grad _obj =
+  [C.throwBlock| bool { return (*$(at::TensorOptions* _obj)).requires_grad(
+    );
+  }|]
+
+tensorOptions_has_requires_grad
+  :: Ptr TensorOptions
+  -> IO (CBool)
+tensorOptions_has_requires_grad _obj =
+  [C.throwBlock| bool { return (*$(at::TensorOptions* _obj)).has_requires_grad(
+    );
+  }|]
+
+tensorOptions_backend
+  :: Ptr TensorOptions
+  -> IO (Backend)
+tensorOptions_backend _obj =
+  [C.throwBlock| at::Backend { return (*$(at::TensorOptions* _obj)).backend(
+    );
+  }|]
+
+dtype_s
+  :: ScalarType
+  -> IO (Ptr TensorOptions)
+dtype_s _dtype =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions(at::dtype(
+    $(at::ScalarType _dtype)));
+  }|]
+
+layout_L
+  :: Layout
+  -> IO (Ptr TensorOptions)
+layout_L _layout =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions(at::layout(
+    $(at::Layout _layout)));
+  }|]
+
+device_D
+  :: DeviceType
+  -> IO (Ptr TensorOptions)
+device_D _device =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions(at::device(
+    $(at::DeviceType _device)));
+  }|]
+
+device_index_s
+  :: Int16
+  -> IO (Ptr TensorOptions)
+device_index_s _device_index =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions(at::device_index(
+    $(int16_t _device_index)));
+  }|]
+
+requires_grad_b
+  :: CBool
+  -> IO (Ptr TensorOptions)
+requires_grad_b _requires_grad =
+  [C.throwBlock| at::TensorOptions* { return new at::TensorOptions(at::requires_grad(
+    $(bool _requires_grad)));
+  }|]
+
diff --git a/src/Torch/Internal/Unmanaged/Type/Tuple.hs b/src/Torch/Internal/Unmanaged/Type/Tuple.hs
new file mode 100644
--- /dev/null
+++ b/src/Torch/Internal/Unmanaged/Type/Tuple.hs
@@ -0,0 +1,330 @@
+
+-- generated by using spec/tuples.yaml
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Torch.Internal.Unmanaged.Type.Tuple where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign
+import Torch.Internal.Type
+import Torch.Internal.Class
+
+import qualified Language.C.Inline.Cpp as C
+import qualified Language.C.Inline.Cpp.Unsafe as C
+import qualified Language.C.Inline.Context as C
+import qualified Language.C.Types as C
+import qualified Data.Map as Map
+
+C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }
+
+C.include "<ATen/Tensor.h>"
+C.include "<tuple>"
+
+
+
+
+-----------------StdTuple '(Tensor,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get2 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get3 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple5 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type E (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get4 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<4>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Tensor,TensorList)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) = Ptr Tensor
+  get2 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList))) = Ptr TensorList
+  get3 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = Ptr Tensor
+  get2 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = Ptr Tensor
+  get3 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>* v)));}|]
+
+instance CppTuple5 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) where
+  type E (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64))) = Int64
+  get4 v = [C.throwBlock| int64_t { return (std::get<4>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Tensor))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Tensor))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Tensor))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Tensor))) = Ptr Tensor
+  get2 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Tensor,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get2 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get3 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,CDouble,Int64)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,double,int64_t>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,double,int64_t>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64))) = CDouble
+  get2 v = [C.throwBlock| double { return (std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,double,int64_t>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,CDouble,Int64))) = Int64
+  get3 v = [C.throwBlock| int64_t { return (std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,double,int64_t>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get2 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get3 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple5 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type E (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get4 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<4>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple6 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type F (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get5 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<5>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple7 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type G (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get6 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<6>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(CDouble,Int64)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(CDouble,Int64))) where
+  type A (Ptr (StdTuple '(CDouble,Int64))) = CDouble
+  type B (Ptr (StdTuple '(CDouble,Int64))) = Int64
+  get0 v = [C.throwBlock| double { return (std::get<0>(*$(std::tuple<double,int64_t>* v)));}|]
+  get1 v = [C.throwBlock| int64_t { return (std::get<1>(*$(std::tuple<double,int64_t>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get2 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get3 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple5 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type E (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get4 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<4>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+instance CppTuple6 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) where
+  type F (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor))) = Ptr Tensor
+  get5 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<5>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,TensorList,TensorList)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,TensorList,TensorList))) where
+  type A (Ptr (StdTuple '(Tensor,TensorList,TensorList))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,TensorList,TensorList))) = Ptr TensorList
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,std::vector<at::Tensor>,std::vector<at::Tensor>>* v)));}|]
+  get1 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<1>(*$(std::tuple<at::Tensor,std::vector<at::Tensor>,std::vector<at::Tensor>>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,TensorList,TensorList))) where
+  type C (Ptr (StdTuple '(Tensor,TensorList,TensorList))) = Ptr TensorList
+  get2 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<2>(*$(std::tuple<at::Tensor,std::vector<at::Tensor>,std::vector<at::Tensor>>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,TensorList)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,TensorList))) where
+  type A (Ptr (StdTuple '(Tensor,TensorList))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,TensorList))) = Ptr TensorList
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,std::vector<at::Tensor>>* v)));}|]
+  get1 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<1>(*$(std::tuple<at::Tensor,std::vector<at::Tensor>>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Ptr Tensor
+  get2 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Ptr Tensor
+  get3 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple5 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type E (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Int64
+  get4 v = [C.throwBlock| int64_t { return (std::get<4>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple6 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type F (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Int64
+  get5 v = [C.throwBlock| int64_t { return (std::get<5>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple7 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type G (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Int64
+  get6 v = [C.throwBlock| int64_t { return (std::get<6>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple8 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type H (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Int64
+  get7 v = [C.throwBlock| int64_t { return (std::get<7>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple9 (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) where
+  type I (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Int64,Int64,Int64,Int64,Tensor))) = Ptr Tensor
+  get8 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<8>(*$(std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,int64_t,int64_t,int64_t,int64_t,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(Tensor,Tensor,Int64,Int64,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) where
+  type A (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) where
+  type C (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = Int64
+  get2 v = [C.throwBlock| int64_t { return (std::get<2>(*$(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) where
+  type D (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = Int64
+  get3 v = [C.throwBlock| int64_t { return (std::get<3>(*$(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor>* v)));}|]
+
+instance CppTuple5 (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) where
+  type E (Ptr (StdTuple '(Tensor,Tensor,Int64,Int64,Tensor))) = Ptr Tensor
+  get4 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<4>(*$(std::tuple<at::Tensor,at::Tensor,int64_t,int64_t,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(TensorList,Tensor)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(TensorList,Tensor))) where
+  type A (Ptr (StdTuple '(TensorList,Tensor))) = Ptr TensorList
+  type B (Ptr (StdTuple '(TensorList,Tensor))) = Ptr Tensor
+  get0 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<0>(*$(std::tuple<std::vector<at::Tensor>,at::Tensor>* v)));}|]
+  get1 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<1>(*$(std::tuple<std::vector<at::Tensor>,at::Tensor>* v)));}|]
+
+
+-----------------StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) where
+  type A (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = Ptr TensorList
+  type B (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = Ptr TensorList
+  get0 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<0>(*$(std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* v)));}|]
+  get1 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<1>(*$(std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* v)));}|]
+
+instance CppTuple3 (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) where
+  type C (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = Ptr TensorList
+  get2 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<2>(*$(std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* v)));}|]
+
+instance CppTuple4 (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) where
+  type D (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = Ptr TensorList
+  get3 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<3>(*$(std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* v)));}|]
+
+instance CppTuple5 (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) where
+  type E (Ptr (StdTuple '(TensorList,TensorList,TensorList,TensorList,TensorList))) = Ptr TensorList
+  get4 v = [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(std::get<4>(*$(std::tuple<std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>,std::vector<at::Tensor>>* v)));}|]
+
+-----------------StdTuple '(Tensor,Generator)---------------------
+
+instance CppTuple2 (Ptr (StdTuple '(Tensor,Generator))) where
+  type A (Ptr (StdTuple '(Tensor,Generator))) = Ptr Tensor
+  type B (Ptr (StdTuple '(Tensor,Generator))) = Ptr Generator
+  get0 v = [C.throwBlock| at::Tensor* { return new at::Tensor(std::get<0>(*$(std::tuple<at::Tensor,at::Generator>* v)));}|]
+  get1 v = [C.throwBlock| at::Generator* { return new at::Generator(std::get<1>(*$(std::tuple<at::Tensor,at::Generator>* v)));}|]
+  makeTuple2 (a,b) = [C.throwBlock| std::tuple<at::Tensor,at::Generator>* { return new std::tuple<at::Tensor,at::Generator>(std::make_tuple(*$(at::Tensor* a),*$(at::Generator* b)));}|]
diff --git a/test/BasicSpec.hs b/test/BasicSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/BasicSpec.hs
@@ -0,0 +1,459 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+
+-- This test does the same test as deps/pytorch/aten/src/ATen/test/basic.cpp
+
+module BasicSpec (spec) where
+
+import Test.Hspec
+import Control.Exception.Safe
+import Control.Monad (forM_,forM,join)
+import Data.Int
+import Foreign
+import Torch.Internal.Const
+import Torch.Internal.Type
+import Torch.Internal.Class
+import Torch.Internal.Managed.Type.TensorOptions
+import Torch.Internal.Managed.Type.Tensor
+import Torch.Internal.Managed.Type.TensorList
+import Torch.Internal.Managed.Type.Extra
+import Torch.Internal.Managed.Type.IntArray
+import Torch.Internal.Managed.Type.Scalar
+import Torch.Internal.Managed.Type.Tuple
+import Torch.Internal.Managed.Type.Context
+import Torch.Internal.Managed.Native
+
+intArray :: [Int64] -> IO (ForeignPtr IntArray)
+intArray dims = do
+  ary <- newIntArray
+  forM_ dims $ intArray_push_back_l ary
+  return ary
+
+tensorList :: [ForeignPtr Tensor] -> IO (ForeignPtr TensorList)
+tensorList dims = do
+  ary <- newTensorList
+  forM_ dims $ tensorList_push_back_t ary
+  return ary
+
+options :: DeviceType -> ScalarType -> IO (ForeignPtr TensorOptions)
+options dtype stype = join $ tensorOptions_dtype_s <$> device_D dtype <*> pure stype
+
+ap1 fn a0  = join $ fn <$> a0
+ap2 fn a0 a1  = join $ fn <$> a0 <*> a1
+ap3 fn a0 a1 a2  = join $ fn <$> a0 <*> a1 <*> a2
+ap4 fn a0 a1 a2 a3 = join $ fn <$> a0 <*> a1 <*> a2 <*> a3
+
+at1 tensor i0 = tensor__at__l tensor i0
+at2 tensor i0 i1 = ap2 tensor__at__l (at1 tensor i0) (pure i1)
+at3 tensor i0 i1 i2 = ap2 tensor__at__l (at2 tensor i0 i1) (pure i2)
+
+new' fn dsize dtype = ap2 fn (intArray dsize) (options kCPU dtype)
+add' a b = join $ add_tts <$> pure a <*> pure b <*> newScalar_d 1
+addM' a b = join $ add_tts <$> a <*> b <*> newScalar_d 1
+add_s' a b = join $ add_tss <$> pure a <*> pure b <*> newScalar_d 1
+addM_s' a b = join $ add_tss <$> a <*> b <*> newScalar_d 1
+
+spec :: Spec
+spec = forM_ [
+  (kFloat,"float"),
+  (kDouble,"double")
+  ] $ \(dtype,dtype_str) -> describe ("BasicSpec:" <> dtype_str) $ do
+-- void TestResize(Type& type) {
+--   auto a = at::empty({0}, type.options());
+--   a.resize_({3, 4});
+--   ASSERT_EQ_RESOLVED(a.numel(), 12);
+--   a.resize_({5, 7});
+--   ASSERT_EQ_RESOLVED(a.numel(), 35);
+-- }
+  it "TestReisze" $ do
+    a <- new' empty_lo [1,1] dtype
+    a1 <- join $ tensor_resize__l <$> pure a <*> intArray [3,4]
+    tensor_numel a1 `shouldReturn` 12
+
+    a2 <- join $ tensor_resize__l <$> pure a <*> intArray [5,7]
+    tensor_numel a2 `shouldReturn` 35
+
+-- void TestOnesAndDot(Type& type) {
+--   Tensor b0 = ones({1, 1}, type);
+--   ASSERT_EQ_RESOLVED((b0 + b0).sum().item<double>(), 2);
+
+--   Tensor b1 = ones({1, 2}, type);
+--   ASSERT_EQ_RESOLVED((b1 + b1).sum().item<double>(), 4);
+
+--   Tensor b = ones({3, 4}, type);
+--   ASSERT_EQ_RESOLVED((b + b).sum().item<double>(), 24);
+--   ASSERT_EQ_RESOLVED(b.numel(), 12);
+--   ASSERT_EQ_RESOLVED(b.view(-1).dot(b.view(-1)).item<double>(), 12);
+-- }
+  it "TestOnesAndDot" $ do
+    b0 <- new' ones_lo [1,1] dtype
+    b01 <- add' b0 b0
+    b02 <- sum_t b01
+    tensor_item_double b02 `shouldReturn` 2
+
+    b0 <- new' ones_lo [1,2] dtype
+    b01 <- add' b0 b0
+    b02 <- sum_t b01
+    tensor_item_double b02 `shouldReturn` 4
+
+    b0 <- new' ones_lo [3,4] dtype
+    b01 <- add' b0 b0
+    b02 <- sum_t b01
+    tensor_item_double b02 `shouldReturn` 24
+    tensor_numel b0 `shouldReturn` 12
+    b03 <- join $ tensor_view_l <$> pure b0 <*> intArray [-1]
+    b04 <- tensor_dot_t b03 b03
+    tensor_item_double b04 `shouldReturn` 12
+
+
+-- void TestSort(Type& type) {
+--   Tensor b = rand({3, 4}, type);
+
+--   auto z = b.sort(1);
+--   auto z_sorted = std::get<0>(z);
+
+--   bool isLT = z_sorted[0][0].item<float>() < z_sorted[0][1].item<float>();
+--   ASSERT_TRUE(isLT);
+-- }
+  it "TestSort" $ do
+    b <- new' rand_lo [3,4] dtype
+    z <- tensor_sort_lb b 1 0 :: IO (ForeignPtr (StdTuple '(Tensor,Tensor)))
+    z_sorted <- get0 z
+    z00 <- at2 z_sorted 0 0 >>= tensor_item_float
+    z01 <- at2 z_sorted 0 1 >>= tensor_item_float
+    z00 < z01 `shouldBe` True
+
+-- void TestRandperm(Type& type) {
+--   if (type.backend() != Backend::CUDA) {
+--     Tensor b = randperm(15, type);
+--     Tensor rv, ri;
+--     std::tie(rv, ri) = sort(b, 0);
+--     bool isLE = (rv[0].item<float>() <= rv[1].item<float>());
+--     ASSERT_TRUE(isLE);
+--   }
+-- }
+
+-- void SendContext() {
+--   std::stringstream ss;
+--   ss << "context: " << std::hex << (int64_t)&globalContext() << std::endl;
+-- }
+
+-- void TestAdd(Type& type) {
+--   Tensor a = rand({3, 4}, type);
+--   Tensor b = rand({3, 4}, type);
+--   Tensor c = add(a, add(a, b));
+--   // TODO:0-dim Tensor d(3.f);
+--   Scalar d = 3.f;
+--   ASSERT_TRUE(add(c, d).allclose(a + a + b + d));
+-- }
+  it "TestAdd" $ do
+    a <- new' rand_lo [3,4] dtype
+    b <- new' rand_lo [3,4] dtype
+    c <- addM' (pure a) (add' a b)
+    d <- newScalar_d 3
+    e <- add_s' c d
+    f <- addM_s' (addM' (add' a a) (pure b)) (pure d)
+    allclose_ttddb e f (1e-05) (1e-08) 0 `shouldReturn` 1
+
+  it "TestAdd2" $ do
+    a <- new' ones_lo [3,4] dtype
+    b <- new' ones_lo [3,4] dtype
+    c <- add' a b
+    (at2 c 0 0 >>= tensor_item_double) `shouldReturn` 2
+
+-- void TestLoadsOfAdds(Type& type) {
+--   auto begin = std::chrono::high_resolution_clock::now();
+--   Tensor d = ones({3, 4}, type);
+--   Tensor r = zeros({3, 4}, type);
+--   for (auto i = 0; i < 100000; i++) {
+--     add_out(r, r, d);
+--   }
+--   auto end = std::chrono::high_resolution_clock::now();
+--   // TODO TEST PERF?
+--   std::cout << std::dec << "   "
+--             << std::chrono::duration_cast<std::chrono::milliseconds>(
+--                    end - begin)
+--                    .count()
+--             << " ms" << std::endl;
+--   ASSERT_EQ_RESOLVED(norm(100000 * d).item<double>(), norm(r).item<double>());
+-- }
+{-
+  it "TestLoadsOfAdds" $ do
+    d <- new' ones_lo [3,4] dtype
+    r <- new' rand_lo [3,4] dtype
+    one <- newScalar_d 1
+    forM_ [0..99999] $ \_ -> do
+      void $ add_out_ttts r r d one
+    a <- join $ tensor_item_double <$> (join $ mul_tss <$> pure d <*> newScalar_i 100000)
+-}
+
+-- void TestLoadOfAddsWithCopy(Type& type) {
+--   auto begin = std::chrono::high_resolution_clock::now();
+--   Tensor d = ones({3, 4}, type);
+--   Tensor r = zeros({3, 4}, type);
+--   for (auto i = 0; i < 100000; i++) {
+--     r = add(r, d);
+--   }
+--   auto end = std::chrono::high_resolution_clock::now();
+--   // TODO TEST PERF?
+--   std::cout << std::dec << "   "
+--             << std::chrono::duration_cast<std::chrono::milliseconds>(
+--                    end - begin)
+--                    .count()
+--             << " ms" << std::endl;
+--   ASSERT_EQ_RESOLVED(norm(100000 * d).item<double>(), norm(r).item<double>());
+-- }
+
+-- void TestIsContiguous(Type& type) {
+--   Tensor a = rand({3, 4}, type);
+--   ASSERT_TRUE(a.is_contiguous());
+--   a = a.transpose(0, 1);
+--   ASSERT_FALSE(a.is_contiguous());
+-- }
+  it "TestIsContiguous" $ do
+    a <- new' rand_lo [3,4] dtype
+    tensor_is_contiguous a `shouldReturn` 1
+    (join $ tensor_is_contiguous <$> tensor_transpose_ll a 0 1) `shouldReturn` 0
+
+-- void TestPermute(Type& type) {
+--   Tensor a = rand({3, 4, 5}, type);
+--   Tensor b = a.permute({1, 2, 0});
+--   ASSERT_TRUE(b.sizes().equals({4, 5, 3}));
+--   ASSERT_TRUE(b.strides().equals({5, 1, 20}));
+-- }
+
+-- void TestMm(Type& type) {
+--   Tensor a = rand({3, 4}, type);
+--   Tensor b = rand({4}, type);
+--   Tensor c = mv(a, b);
+--   ASSERT_TRUE(c.equal(addmv(zeros({3}, type), a, b, 0, 1)));
+-- }
+  it "TTestMm" $ do
+    a <- new' rand_lo [3,4] dtype
+    b <- new' rand_lo [4] dtype
+    c <- mv_tt a b
+    z <- new' zeros_lo [3] dtype
+    d <- join $ addmv_tttss <$> pure z <*> pure a <*> pure b <*> newScalar_d 0 <*> newScalar_d 1
+    tensor_equal_t c d `shouldReturn` 1
+
+-- void TestSqueeze(Type& type) {
+--   Tensor a = rand({2, 1}, type);
+--   Tensor b = squeeze(a);
+--   ASSERT_EQ_RESOLVED(b.dim(), 1);
+--   a = rand({1}, type);
+--   b = squeeze(a);
+--   // TODO 0-dim squeeze
+--   ASSERT_TRUE(a[0].equal(b));
+-- }
+  it "TestSqueeze" $ do
+    a <- new' rand_lo [2,1] dtype
+    b <- squeeze_t a
+    tensor_dim b `shouldReturn` 1
+    a <- new' rand_lo [1] dtype
+    b <- squeeze_t a
+    (join $ tensor_equal_t <$> (tensor__at__l a 0) <*> pure b) `shouldReturn` 1
+
+-- void TestCopy(Type& type) {
+--   Tensor a = zeros({4, 3}, type);
+--   Tensor e = rand({4, 3}, type);
+--   a.copy_(e);
+--   ASSERT_TRUE(a.equal(e));
+-- }
+  it "TTestCopy" $ do
+    a <- new' zeros_lo [4,3] dtype
+    e <- new' rand_lo [4,3] dtype
+    _ <- tensor_copy__tb a e 0
+    tensor_equal_t a e `shouldReturn` 1
+
+-- void TestCopyBroadcasting(Type& type) {
+--   Tensor a = zeros({4, 3}, type);
+--   Tensor e = rand({3}, type);
+--   a.copy_(e);
+--   for (int i = 0; i < 4; ++i) {
+--     ASSERT_TRUE(a[i].equal(e));
+--   }
+-- }
+  it "TestCopyBroadcasting" $ do
+    a <- new' zeros_lo [4,3] dtype
+    e <- new' rand_lo [3] dtype
+    _ <- tensor_copy__tb a e 0
+    forM_ [0..3] $ \i -> do
+      (join $ tensor_equal_t <$>  tensor__at__l a i <*> pure e) `shouldReturn` 1
+
+-- void TestAbsValue(Type& type) {
+--   Tensor r = at::abs(at::scalar_tensor(-3, type.options()));
+--   ASSERT_EQ_RESOLVED(r.item<int32_t>(), 3);
+-- }
+  it "TestAbsValue" $ do
+    r <- join $ abs_t <$> (join $ scalar_tensor_so <$> newScalar_i (-3) <*> options kCPU dtype)
+    tensor_item_float r `shouldReturn` 3
+
+-- void TestAddingAValueWithScalar(Type& type) {
+--   Tensor a = rand({4, 3}, type);
+--   ASSERT_TRUE((ones({4, 3}, type) + a).equal(add(a, 1)));
+-- }
+  it "TestAddingAValueWithScalar" $ do
+    a <- new' rand_lo [4, 3] dtype
+    b <- new' ones_lo [4, 3] dtype
+    one <- newScalar_d 1
+    c <- add' b a
+    d <- add_s' a one
+    tensor_equal_t c d  `shouldReturn` 1
+
+-- void TestSelect(Type& type) {
+--   Tensor a = rand({3, 7}, type);
+--   auto a_13 = select(a, 1, 3);
+--   auto a_13_02 = select(select(a, 1, 3), 0, 2);
+--   ASSERT_TRUE(a[0][3].equal(a_13[0]));
+--   ASSERT_TRUE(a[2][3].equal(a_13_02));
+-- }
+  it "TestSelect" $ do
+    a <- new' rand_lo [3, 7] dtype
+    a13 <- select_tll a 1 3
+    a13_02 <- ap3 select_tll (select_tll a 1 3) (pure 0) (pure 2)
+    ap2 tensor_equal_t (at2 a 0 3) (at1 a13 0) `shouldReturn` 1
+    ap2 tensor_equal_t (at2 a 2 3) (pure a13_02) `shouldReturn` 1
+
+
+-- void TestZeroDim(Type& type) {
+--   Tensor a = at::scalar_tensor(4, type.options()); // rand(type, {1});
+
+--   Tensor b = rand({3, 4}, type);
+--   ASSERT_EQ_RESOLVED((a + a).dim(), 0);
+--   ASSERT_EQ_RESOLVED((1 + a).dim(), 0);
+--   ASSERT_EQ_RESOLVED((b + a).dim(), 2);
+--   ASSERT_EQ_RESOLVED((a + b).dim(), 2);
+--   auto c = rand({3, 4}, type);
+--   ASSERT_EQ_RESOLVED(c[1][2].dim(), 0);
+
+--   auto f = rand({3, 4}, type);
+--   f[2] = zeros({4}, type);
+--   f[1][0] = -1;
+--   ASSERT_EQ_RESOLVED(f[2][0].item<double>(), 0);
+-- }
+  it "TestZeroDim" $ do
+    a <- ap2 scalar_tensor_so (newScalar_i 4) (options kCPU dtype)
+    b <- new' rand_lo [3,4] dtype
+    one <- newScalar_d 1
+    (add' a a     >>= tensor_dim) `shouldReturn` 0
+    (add_s' a one >>= tensor_dim) `shouldReturn` 0
+    (add' b a     >>= tensor_dim) `shouldReturn` 2
+    (add' a b     >>= tensor_dim) `shouldReturn` 2
+    c <- new' rand_lo [3,4] dtype
+    (at2 c 1 2    >>= tensor_dim) `shouldReturn` 0
+    f <- new' rand_lo [3,4] dtype
+    ap3 tensor_assign1_t (pure f) (pure 2) (new' zeros_lo [4] dtype)
+    tensor_assign2_l f 1 0 (-1)
+    (at2 f 2 0 >>= tensor_item_double) `shouldReturn` 0
+
+
+-- void TestTensorFromTH() {
+--   int a = 4;
+--   THFloatTensor* t = THFloatTensor_newWithSize2d(a, a);
+--   THFloatTensor_fill(t, a);
+--   ASSERT_NO_THROW(CPU(kFloat).unsafeTensorFromTH(t, false));
+-- }
+
+-- void TestToCFloat() {
+--   Tensor a = zeros({3, 4});
+--   Tensor b = ones({3, 7});
+--   Tensor c = cat({a, b}, 1);
+--   ASSERT_EQ_RESOLVED(c.size(1), 11);
+--   Tensor e = rand({});
+--   ASSERT_EQ_RESOLVED(*e.data<float>(), e.sum().item<float>());
+-- }
+  -- it "TestToCFloat" $ do
+  --   a <- new' zeros_lo [3,4] dtype
+  --   b <- new' ones_lo [3,7] dtype
+  --   c <- ap2 cat_ll (tensorList [a,b]) (pure 1)
+  --   tensor_size_l c 1 `shouldReturn` 11
+
+-- void TestToString() {
+--   Tensor b = ones({3, 7}) * .0000001f;
+--   std::stringstream s;
+--   s << b << "\n";
+--   std::string expect = "1e-07 *";
+--   ASSERT_EQ_RESOLVED(s.str().substr(0, expect.size()), expect);
+-- }
+
+-- void TestIndexingByScalar() {
+--   Tensor tensor = arange(0, 10, kInt);
+--   Tensor one = ones({}, kInt);
+--   for (int64_t i = 0; i < tensor.numel(); ++i) {
+--     ASSERT_TRUE(tensor[i].equal(one * i));
+--   }
+--   for (size_t i = 0; i < static_cast<uint64_t>(tensor.numel()); ++i) {
+--     ASSERT_TRUE(tensor[i].equal(one * static_cast<int64_t>(i)));
+--   }
+--   for (int i = 0; i < tensor.numel(); ++i) {
+--     ASSERT_TRUE(tensor[i].equal(one * i));
+--   }
+--   for (int16_t i = 0; i < tensor.numel(); ++i) {
+--     ASSERT_TRUE(tensor[i].equal(one * i));
+--   }
+--   for (int8_t i = 0; i < tensor.numel(); ++i) {
+--     ASSERT_TRUE(tensor[i].equal(one * i));
+--   }
+--   // Throw StartsWith("Can only index tensors with integral scalars")
+--   ASSERT_ANY_THROW(tensor[Scalar(3.14)].equal(one));
+-- }
+  it "TestIndexingByScalar" $ do
+    tensor <- ap3 arange_sso (newScalar_i 0) (newScalar_i 10) (options kCPU kInt)
+    one <- new' ones_lo [] kInt
+    num <- tensor_numel tensor
+    forM_ [0..(num-1)] $ \i -> do
+      ap2 tensor_equal_t (at1 tensor i) (ap2 mul_ts (pure one) (newScalar_i (fromIntegral i))) `shouldReturn` 1
+    forM_ [0..(num-1)] $ \i -> do
+      ap2 tensor_equal_t (at1 tensor i) (ap2 mul_ts (pure one) (newScalar_i (fromIntegral i))) `shouldReturn` 1
+    at1 tensor 314 `shouldThrow` anyException
+
+
+-- void TestIndexingByZerodimTensor() {
+--   Tensor tensor = arange(0, 10, kInt);
+--   Tensor one = ones({}, kInt);
+--   for (int i = 0; i < tensor.numel(); ++i) {
+--     ASSERT_TRUE(tensor[one * i].equal(one * i));
+--   }
+--   // Throw StartsWith(
+--   //            "Can only index tensors with integral scalars")
+--   ASSERT_ANY_THROW(tensor[ones({}) * 3.14].equal(one));
+--   // Throw StartsWith("Can only index with tensors that are defined")
+--   ASSERT_ANY_THROW(tensor[Tensor()].equal(one));
+--   // Throw StartsWith("Can only index with tensors that are scalars (zero-dim)")
+--   ASSERT_ANY_THROW(tensor[ones({2, 3, 4}, kInt)].equal(one));
+-- }
+-- void TestIndexingMixedDevice(Type& type) {
+--   Tensor tensor = randn({20, 20}, type);
+--   Tensor index = arange(10, kLong).cpu();
+--   Tensor result = tensor.index({index});
+--   ASSERT_TRUE(result[0].equal(tensor[0]));
+-- }
+-- void TestDispatch() {
+--   Tensor tensor = randn({20, 20});
+--   Tensor other = randn({20, 20});
+--   auto result = tensor.m(relu).m(mse_loss, other, Reduction::Mean);
+--   ASSERT_TRUE(result.allclose(mse_loss(relu(tensor), other)));
+-- }
+
+-- void TestNegativeDim(Type& type) {
+--   ASSERT_ANY_THROW(empty({5, -5, 5}, type.options()));
+--   ASSERT_ANY_THROW(empty({5, -5, -5}, type.options()));
+--   Tensor tensor = empty({5, 5}, type.options());
+--   ASSERT_ANY_THROW(tensor.reshape({-5, -5}));
+-- }
+
+-- TEST(BasicTest, BasicTestCPU) {
+--   manual_seed(123);
+
+--   test(CPU(kFloat));
+-- }
+
+-- TEST(BasicTest, BasicTestCUDA) {
+--   manual_seed(123);
+
+--   if (at::hasCUDA()) {
+--     test(CUDA(kFloat));
+--   }
+-- }
+
diff --git a/test/CudaSpec.hs b/test/CudaSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/CudaSpec.hs
@@ -0,0 +1,40 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+module CudaSpec (main, spec) where
+
+import Test.Hspec
+import Control.Exception.Safe (bracket,catch,throwIO)
+import Control.Monad (forM_,forM)
+import Data.Int
+import Foreign
+import Torch.Internal.Const
+import Torch.Internal.Type
+import Torch.Internal.Managed.Type.TensorOptions
+import Torch.Internal.Managed.Type.Tensor
+import Torch.Internal.Managed.Type.IntArray
+import Torch.Internal.Managed.Type.Context
+import Torch.Internal.Managed.Native
+import Torch.Internal.GC
+
+main :: IO ()
+main = hspec spec
+
+spec :: Spec
+spec = do
+  describe "CudaSpec" $ do
+    it "When CUDA is out of memory, do GC and retry" $ do
+      flag <- hasCUDA
+      monitorMemory $ do
+        forM_ [0..1000] $ \i -> do -- 80MByte x 1000 = 80GByte
+          dims <- fromList [1000,1000,10] -- 8 byte x 10M = 80MByte
+          to <- device_D $ if flag == 0 then kCPU else kCUDA
+          tod <- tensorOptions_dtype_s to kDouble
+          zeros_lo dims tod
+          return ()
+
+fromList :: [Int64] -> IO (ForeignPtr IntArray)
+fromList dims = do
+  ary <- newIntArray
+  forM_ dims $ intArray_push_back_l ary
+  return ary
diff --git a/test/GeneratorSpec.hs b/test/GeneratorSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/GeneratorSpec.hs
@@ -0,0 +1,30 @@
+module GeneratorSpec (main, spec) where
+
+import Test.Hspec
+import Control.Exception (bracket)
+import Control.Monad (forM_,forM)
+import Data.Int
+import Foreign
+import Torch.Internal.Const
+import Torch.Internal.Type
+import Torch.Internal.Managed.Type.Generator
+import qualified Torch.Internal.Unmanaged.Type.Generator as U
+import Torch.Internal.Managed.Type.TensorOptions
+import Torch.Internal.Managed.Type.Tensor
+import Torch.Internal.Managed.Type.IntArray
+import Torch.Internal.Managed.Type.Context
+import Torch.Internal.Managed.Native
+
+main :: IO ()
+main = hspec spec
+
+spec :: Spec
+spec = do
+  describe "GeneratorSpec" $ do
+    it "create generator" $ do
+      g <- newCPUGenerator 123
+      generator_current_seed g `shouldReturn` 123
+    it "get default generator" $ do
+      g <- U.getDefaultCPUGenerator
+      manual_seed_L 321
+      U.generator_current_seed g `shouldReturn` 321
diff --git a/test/MemorySpec.hs b/test/MemorySpec.hs
new file mode 100644
--- /dev/null
+++ b/test/MemorySpec.hs
@@ -0,0 +1,120 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+module MemorySpec (main, spec) where
+
+import Test.Hspec
+import Control.Exception (bracket)
+import Control.Monad (forM_,forM)
+import Data.Int
+import Foreign
+import Torch.Internal.Const
+import Torch.Internal.Type
+import Torch.Internal.Managed.Type.TensorOptions
+import Torch.Internal.Managed.Type.Tensor
+import Torch.Internal.Managed.Type.IntArray
+import Torch.Internal.Managed.Type.Context
+import Torch.Internal.Managed.Native
+
+import System.Mem ()
+
+-- |Confirm that memory is deallocated (works)
+main :: IO ()
+main = hspec spec
+
+--type SomeDims = IntArray
+
+spec :: Spec
+spec = do
+  describe "MemorySpec" $ do
+    it "scenario: memoryTestMinimal" memoryTestMinimal
+
+
+fromList :: [Int64] -> IO (ForeignPtr IntArray)
+fromList dims = do
+  ary <- newIntArray
+  forM_ dims $ intArray_push_back_l ary
+  return ary
+
+newTensor_zeros :: (ForeignPtr IntArray) -> IO (ForeignPtr Tensor)
+newTensor_zeros dims = do
+  flag <- hasCUDA
+  to <- device_D $ if flag == 0 then kCPU else kCUDA
+  tod <- tensorOptions_dtype_s to kByte
+  zeros_lo dims tod
+
+totalDim :: (ForeignPtr IntArray) -> IO Int64
+totalDim dims = do
+  size <- intArray_size dims
+  dims' <- forM [0..(size-1)] $ \i -> intArray_at_s dims i
+  return $ sum dims'
+
+iterator :: (ForeignPtr IntArray) -> Int -> IO ()
+iterator = iteratorBracket
+
+-- |Leaks memory
+iteratorAssign :: (ForeignPtr IntArray) -> Int -> IO ()
+iteratorAssign d niter = do
+  size <- memSizeGB d
+  putStrLn $ show size ++ " GB per allocation x " ++ show niter
+  forM_ [1..niter] $ \iter -> do
+    putStr ("Iteration : " ++ show iter ++ " / ")
+    x <- newTensor_zeros d
+    v <- tensor_dim x
+    putStr $ "Printing dummy value: " ++ show v ++ "\r"
+  putStrLn "Done"
+
+-- |Releases memory on OSX (but not consistently on linux)
+iteratorMonadic :: (ForeignPtr IntArray) -> Int -> IO ()
+iteratorMonadic d niter = do
+  size <- memSizeGB d
+  putStrLn $ show size ++ " GB per allocation x " ++ show niter
+  forM_ [1..niter] $ \iter -> do
+    putStr ("Iteration : " ++ show iter ++ " / ")
+    x <- newTensor_zeros d
+    v <- tensor_dim x
+    putStr $ "Printing dummy value: " ++ show v ++ "\r"
+  putStrLn "Done"
+
+-- |Releases memory
+iteratorBracket :: (ForeignPtr IntArray) -> Int -> IO ()
+iteratorBracket d niter = do
+  size <- memSizeGB d
+  putStrLn $ show size ++ " GB per allocation x " ++ show niter
+  forM_ [1..niter] $ \iter ->
+    bracket (pure iter)
+    (\iter -> do
+       putStr ("Iteration : " ++ show iter ++ " / ")
+       x <- newTensor_zeros d
+       v <- tensor_dim x
+       putStr $ "Printing dummy value: " ++ show v ++ "\r"
+    )
+    (const (pure ()))
+  putStrLn "Done"
+
+
+-- |getDim' size per allocation
+memSizeGB :: (ForeignPtr IntArray) -> IO Double
+memSizeGB d = do
+  td <- totalDim d
+  return $ (fromIntegral td * 8) / 1000000000.0
+
+memoryTestLarge :: IO ()
+memoryTestLarge = do
+  dims <- fromList [200, 200, 200, 200]
+  iterator dims 1000000 -- 12.8 GB x 1M = 12M GB
+
+memoryTestSmall :: IO ()
+memoryTestSmall = do
+  dims <- fromList [100, 100, 100, 7] 
+  iterator dims 300 -- 50 MB x 300 = 15 GB
+
+memoryTestFast :: IO ()
+memoryTestFast = do
+  dims <- fromList [50, 50, 50, 5]
+  iterator dims 10000 -- 5 MB x 1000 = 5 GB
+
+memoryTestMinimal :: IO ()
+memoryTestMinimal = do
+  dims <- fromList [50, 50, 50, 5]
+  iterator dims 100 -- 5 MB x 100 = 500 MB
diff --git a/test/Spec.hs b/test/Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/Spec.hs
@@ -0,0 +1,17 @@
+{-# LANGUAGE CPP #-}
+module Main where
+
+import Test.Hspec (hspec)
+import qualified BasicSpec
+import qualified CudaSpec
+import qualified GeneratorSpec
+import qualified MemorySpec
+
+main :: IO ()
+main = hspec $ do
+  BasicSpec.spec
+#ifndef darwin_HOST_OS
+  CudaSpec.spec
+#endif
+  GeneratorSpec.spec
+  MemorySpec.spec