-- 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>"


unique_dim_tlbbb
  :: Ptr Tensor
  -> Int64
  -> CBool
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
unique_dim_tlbbb :: Ptr Tensor
-> Int64
-> CBool
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_tlbbb Ptr Tensor
_self Int64
_dim CBool
_sorted CBool
_return_inverse CBool
_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 :: Ptr Tensor
-> Int64
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_tlbb Ptr Tensor
_self Int64
_dim CBool
_sorted CBool
_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 :: Ptr Tensor
-> Int64 -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_tlb Ptr Tensor
_self Int64
_dim CBool
_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 :: Ptr Tensor
-> Int64 -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_tl Ptr Tensor
_self Int64
_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 :: Ptr Tensor
-> CBool
-> CBool
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_consecutive_tbbl Ptr Tensor
_self CBool
_return_inverse CBool
_return_counts Int64
_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 :: Ptr Tensor
-> CBool -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_consecutive_tbb Ptr Tensor
_self CBool
_return_inverse CBool
_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 :: Ptr Tensor
-> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_consecutive_tb Ptr Tensor
_self CBool
_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 :: Ptr Tensor -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_consecutive_t Ptr Tensor
_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 :: Ptr Tensor
-> Int64
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_consecutive_tlbb Ptr Tensor
_self Int64
_dim CBool
_return_inverse CBool
_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 :: Ptr Tensor
-> Int64 -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_consecutive_tlb Ptr Tensor
_self Int64
_dim CBool
_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 :: Ptr Tensor
-> Int64 -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_consecutive_tl Ptr Tensor
_self Int64
_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 :: Ptr Tensor
-> CBool
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_unique2_tbbb Ptr Tensor
_self CBool
_sorted CBool
_return_inverse CBool
_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 :: Ptr Tensor
-> CBool -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_unique2_tbb Ptr Tensor
_self CBool
_sorted CBool
_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 :: Ptr Tensor
-> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_unique2_tb Ptr Tensor
_self CBool
_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 :: Ptr Tensor -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_unique2_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_unsafe_view_tl Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
unsqueeze_tl Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
vander_tlb Ptr Tensor
_x Int64
_N CBool
_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 :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
vander_tl Ptr Tensor
_x Int64
_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 :: Ptr Tensor -> IO (Ptr Tensor)
vander_t Ptr Tensor
_x =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::vander(
    *$(at::Tensor* _x)));
  }|]

var_tb
  :: Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
var_tb :: Ptr Tensor -> CBool -> IO (Ptr Tensor)
var_tb Ptr Tensor
_self CBool
_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 :: Ptr Tensor -> IO (Ptr Tensor)
var_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr IntArray -> CBool -> CBool -> IO (Ptr Tensor)
var_tlbb Ptr Tensor
_self Ptr IntArray
_dim CBool
_unbiased CBool
_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 :: Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
var_tlb Ptr Tensor
_self Ptr IntArray
_dim CBool
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
var_tl Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor -> Ptr IntArray -> Int64 -> CBool -> IO (Ptr Tensor)
var_tllb Ptr Tensor
_self Ptr IntArray
_dim Int64
_correction CBool
_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 :: Ptr Tensor -> Ptr IntArray -> Int64 -> IO (Ptr Tensor)
var_tll Ptr Tensor
_self Ptr IntArray
_dim Int64
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> CBool -> IO (Ptr Tensor)
var_out_ttlbb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_unbiased CBool
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
var_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
var_out_ttl Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> Int64 -> CBool -> IO (Ptr Tensor)
var_out_ttllb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim Int64
_correction CBool
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> Int64 -> IO (Ptr Tensor)
var_out_ttll Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim Int64
_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_tNbb
  :: Ptr Tensor
  -> Ptr DimnameList
  -> CBool
  -> CBool
  -> IO (Ptr Tensor)
var_tNbb :: Ptr Tensor -> Ptr DimnameList -> CBool -> CBool -> IO (Ptr Tensor)
var_tNbb Ptr Tensor
_self Ptr DimnameList
_dim CBool
_unbiased CBool
_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 :: Ptr Tensor -> Ptr DimnameList -> CBool -> IO (Ptr Tensor)
var_tNb Ptr Tensor
_self Ptr DimnameList
_dim CBool
_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 :: Ptr Tensor -> Ptr DimnameList -> IO (Ptr Tensor)
var_tN Ptr Tensor
_self Ptr DimnameList
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr DimnameList
-> CBool
-> CBool
-> IO (Ptr Tensor)
var_out_ttNbb Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim CBool
_unbiased CBool
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr DimnameList -> CBool -> IO (Ptr Tensor)
var_out_ttNb Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr DimnameList -> IO (Ptr Tensor)
var_out_ttN Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_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 :: Ptr Tensor -> Ptr DimnameList -> Int64 -> CBool -> IO (Ptr Tensor)
var_tNlb Ptr Tensor
_self Ptr DimnameList
_dim Int64
_correction CBool
_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 :: Ptr Tensor -> Ptr DimnameList -> Int64 -> IO (Ptr Tensor)
var_tNl Ptr Tensor
_self Ptr DimnameList
_dim Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr DimnameList
-> Int64
-> CBool
-> IO (Ptr Tensor)
var_out_ttNlb Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim Int64
_correction CBool
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr DimnameList -> Int64 -> IO (Ptr Tensor)
var_out_ttNl Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim Int64
_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 :: Ptr Tensor -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tb Ptr Tensor
_self CBool
_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 :: Ptr Tensor -> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr IntArray
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tlbb Ptr Tensor
_self Ptr IntArray
_dim CBool
_unbiased CBool
_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 :: Ptr Tensor
-> Ptr IntArray -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tlb Ptr Tensor
_self Ptr IntArray
_dim CBool
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tl Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor
-> Ptr IntArray
-> Int64
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tllb Ptr Tensor
_self Ptr IntArray
_dim Int64
_correction CBool
_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 :: Ptr Tensor
-> Ptr IntArray -> Int64 -> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tll Ptr Tensor
_self Ptr IntArray
_dim Int64
_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 :: Ptr Tensor
-> Ptr DimnameList
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tNbb Ptr Tensor
_self Ptr DimnameList
_dim CBool
_unbiased CBool
_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 :: Ptr Tensor
-> Ptr DimnameList
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tNb Ptr Tensor
_self Ptr DimnameList
_dim CBool
_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 :: Ptr Tensor
-> Ptr DimnameList -> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tN Ptr Tensor
_self Ptr DimnameList
_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 :: Ptr Tensor
-> Ptr DimnameList
-> Int64
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tNlb Ptr Tensor
_self Ptr DimnameList
_dim Int64
_correction CBool
_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 :: Ptr Tensor
-> Ptr DimnameList
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_tNl Ptr Tensor
_self Ptr DimnameList
_dim Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
where_ttt Ptr Tensor
_condition Ptr Tensor
_self Ptr Tensor
_other =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::where(
    *$(at::Tensor* _condition)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _other)));
  }|]

where_tst
  :: Ptr Tensor
  -> Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
where_tst :: Ptr Tensor -> Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
where_tst Ptr Tensor
_condition Ptr Scalar
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
where_tts Ptr Tensor
_condition Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
where_tss Ptr Tensor
_condition Ptr Scalar
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr TensorList)
where_t Ptr Tensor
_condition =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::where(
    *$(at::Tensor* _condition)));
  }|]

_s_where_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_s_where_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_s_where_ttt Ptr Tensor
_condition Ptr Tensor
_self Ptr Tensor
_other =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_s_where(
    *$(at::Tensor* _condition)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _other)));
  }|]

norm_except_dim_tll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
norm_except_dim_tll :: Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
norm_except_dim_tll Ptr Tensor
_v Int64
_pow Int64
_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 :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
norm_except_dim_tl Ptr Tensor
_v Int64
_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 :: Ptr Tensor -> IO (Ptr Tensor)
norm_except_dim_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
_weight_norm_ttl Ptr Tensor
_v Ptr Tensor
_g Int64
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_weight_norm_tt Ptr Tensor
_v Ptr Tensor
_g =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_weight_norm(
    *$(at::Tensor* _v)
  , *$(at::Tensor* _g)));
  }|]

_weight_norm_cuda_interface_ttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_weight_norm_cuda_interface_ttl :: Ptr Tensor
-> Ptr Tensor -> Int64 -> IO (Ptr (StdTuple '(Tensor, Tensor)))
_weight_norm_cuda_interface_ttl Ptr Tensor
_v Ptr Tensor
_g Int64
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_cuda_interface(
    *$(at::Tensor* _v)
  , *$(at::Tensor* _g)
  , $(int64_t _dim)));
  }|]

_weight_norm_cuda_interface_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_weight_norm_cuda_interface_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr (StdTuple '(Tensor, Tensor)))
_weight_norm_cuda_interface_tt Ptr Tensor
_v Ptr Tensor
_g =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_cuda_interface(
    *$(at::Tensor* _v)
  , *$(at::Tensor* _g)));
  }|]

_weight_norm_cuda_interface_backward_ttttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_weight_norm_cuda_interface_backward_ttttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_weight_norm_cuda_interface_backward_ttttl Ptr Tensor
_grad_w Ptr Tensor
_saved_v Ptr Tensor
_saved_g Ptr Tensor
_saved_norms Int64
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_cuda_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_weight_norm_differentiable_backward_ttttl Ptr Tensor
_grad_w Ptr Tensor
_saved_v Ptr Tensor
_saved_g Ptr Tensor
_saved_norms Int64
_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 :: Ptr IntArray
-> Ptr DimnameList -> Ptr TensorOptions -> IO (Ptr Tensor)
zeros_lNo Ptr IntArray
_size Ptr DimnameList
_names Ptr TensorOptions
_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 :: Ptr IntArray -> Ptr DimnameList -> IO (Ptr Tensor)
zeros_lN Ptr IntArray
_size Ptr DimnameList
_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 :: Ptr IntArray -> Ptr TensorOptions -> IO (Ptr Tensor)
_efficientzerotensor_lo Ptr IntArray
_size Ptr TensorOptions
_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 :: Ptr IntArray -> IO (Ptr Tensor)
_efficientzerotensor_l Ptr IntArray
_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 :: Ptr IntArray -> Ptr TensorOptions -> IO (Ptr Tensor)
zeros_lo Ptr IntArray
_size Ptr TensorOptions
_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 :: Ptr IntArray -> IO (Ptr Tensor)
zeros_l Ptr IntArray
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
zeros_out_tl Ptr Tensor
_out Ptr IntArray
_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 :: Ptr Tensor -> Ptr TensorOptions -> MemoryFormat -> IO (Ptr Tensor)
zeros_like_toM Ptr Tensor
_self Ptr TensorOptions
_options MemoryFormat
_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 :: Ptr Tensor -> Ptr TensorOptions -> IO (Ptr Tensor)
zeros_like_to Ptr Tensor
_self Ptr TensorOptions
_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 :: Ptr Tensor -> IO (Ptr Tensor)
zeros_like_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_standard_gamma_grad_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
_standard_gamma_tG Ptr Tensor
_self Ptr Generator
_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 :: Ptr Tensor -> IO (Ptr Tensor)
_standard_gamma_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_dirichlet_grad_ttt Ptr Tensor
_x Ptr Tensor
_alpha Ptr Tensor
_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 :: Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
_sample_dirichlet_tG Ptr Tensor
_self Ptr Generator
_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 :: Ptr Tensor -> IO (Ptr Tensor)
_sample_dirichlet_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
poisson_tG Ptr Tensor
_self Ptr Generator
_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 :: Ptr Tensor -> IO (Ptr Tensor)
poisson_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
binomial_ttG Ptr Tensor
_count Ptr Tensor
_prob Ptr Generator
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
binomial_tt Ptr Tensor
_count Ptr Tensor
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
native_norm_ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr Tensor)
native_norm_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Scalar
-> Ptr IntArray
-> CBool
-> MemoryFormat
-> IO (Ptr Tensor)
native_norm_tslbs Ptr Tensor
_self Ptr Scalar
_p Ptr IntArray
_dim CBool
_keepdim MemoryFormat
_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 :: Ptr Tensor -> IO (Ptr Tensor)
_sparse_sum_t Ptr Tensor
_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 :: Ptr Tensor -> MemoryFormat -> IO (Ptr Tensor)
_sparse_sum_ts Ptr Tensor
_self MemoryFormat
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_sparse_sum_tl Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor -> Ptr IntArray -> MemoryFormat -> IO (Ptr Tensor)
_sparse_sum_tls Ptr Tensor
_self Ptr IntArray
_dim MemoryFormat
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_sparse_sum_backward_ttl Ptr Tensor
_grad Ptr Tensor
_self Ptr IntArray
_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_softmax_tls
  :: Ptr Tensor
  -> Int64
  -> ScalarType
  -> IO (Ptr Tensor)
_sparse_softmax_tls :: Ptr Tensor -> Int64 -> MemoryFormat -> IO (Ptr Tensor)
_sparse_softmax_tls Ptr Tensor
_self Int64
_dim MemoryFormat
_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 :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
_sparse_softmax_tl Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> Ptr Dimname -> MemoryFormat -> IO (Ptr Tensor)
_sparse_softmax_tns Ptr Tensor
_self Ptr Dimname
_dim MemoryFormat
_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 :: Ptr Tensor -> Ptr Dimname -> IO (Ptr Tensor)
_sparse_softmax_tn Ptr Tensor
_self Ptr Dimname
_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 :: Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
_sparse_softmax_tlb Ptr Tensor
_self Int64
_dim CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> Ptr Tensor -> IO (Ptr Tensor)
_sparse_softmax_backward_data_ttlt Ptr Tensor
_grad_output Ptr Tensor
_output Int64
_dim Ptr Tensor
_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 :: Ptr Tensor -> Int64 -> MemoryFormat -> IO (Ptr Tensor)
_sparse_log_softmax_tls Ptr Tensor
_self Int64
_dim MemoryFormat
_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 :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
_sparse_log_softmax_tl Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> Ptr Dimname -> MemoryFormat -> IO (Ptr Tensor)
_sparse_log_softmax_tns Ptr Tensor
_self Ptr Dimname
_dim MemoryFormat
_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 :: Ptr Tensor -> Ptr Dimname -> IO (Ptr Tensor)
_sparse_log_softmax_tn Ptr Tensor
_self Ptr Dimname
_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 :: Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
_sparse_log_softmax_tlb Ptr Tensor
_self Int64
_dim CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> Ptr Tensor -> IO (Ptr Tensor)
_sparse_log_softmax_backward_data_ttlt Ptr Tensor
_grad_output Ptr Tensor
_output Int64
_dim Ptr Tensor
_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)));
  }|]

norm_tss
  :: Ptr Tensor
  -> Ptr Scalar
  -> ScalarType
  -> IO (Ptr Tensor)
norm_tss :: Ptr Tensor -> Ptr Scalar -> MemoryFormat -> IO (Ptr Tensor)
norm_tss Ptr Tensor
_self Ptr Scalar
_p MemoryFormat
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
norm_ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr Tensor)
norm_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Scalar
-> Ptr IntArray
-> CBool
-> MemoryFormat
-> IO (Ptr Tensor)
norm_tslbs Ptr Tensor
_self Ptr Scalar
_p Ptr IntArray
_dim CBool
_keepdim MemoryFormat
_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 :: Ptr Tensor
-> Ptr Scalar -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
norm_tslb Ptr Tensor
_self Ptr Scalar
_p Ptr IntArray
_dim CBool
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr IntArray -> IO (Ptr Tensor)
norm_tsl Ptr Tensor
_self Ptr Scalar
_p Ptr IntArray
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr IntArray
-> CBool
-> MemoryFormat
-> IO (Ptr Tensor)
norm_out_ttslbs Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_p Ptr IntArray
_dim CBool
_keepdim MemoryFormat
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
norm_out_ttslb Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_p Ptr IntArray
_dim CBool
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr IntArray -> IO (Ptr Tensor)
norm_out_ttsl Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_p Ptr IntArray
_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 :: Ptr Tensor
-> Ptr Scalar
-> Ptr DimnameList
-> CBool
-> MemoryFormat
-> IO (Ptr Tensor)
norm_tsNbs Ptr Tensor
_self Ptr Scalar
_p Ptr DimnameList
_dim CBool
_keepdim MemoryFormat
_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 :: Ptr Tensor
-> Ptr Scalar -> Ptr DimnameList -> CBool -> IO (Ptr Tensor)
norm_tsNb Ptr Tensor
_self Ptr Scalar
_p Ptr DimnameList
_dim CBool
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr DimnameList -> IO (Ptr Tensor)
norm_tsN Ptr Tensor
_self Ptr Scalar
_p Ptr DimnameList
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr DimnameList
-> CBool
-> MemoryFormat
-> IO (Ptr Tensor)
norm_out_ttsNbs Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_p Ptr DimnameList
_dim CBool
_keepdim MemoryFormat
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr DimnameList
-> CBool
-> IO (Ptr Tensor)
norm_out_ttsNb Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_p Ptr DimnameList
_dim CBool
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr DimnameList -> IO (Ptr Tensor)
norm_out_ttsN Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_p Ptr DimnameList
_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 :: Ptr Tensor -> IO (Ptr (StdTuple '(Tensor, Tensor)))
frexp_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
frexp_out_ttt Ptr Tensor
_mantissa Ptr Tensor
_exponent Ptr Tensor
_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_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
frobenius_norm_t :: Ptr Tensor -> IO (Ptr Tensor)
frobenius_norm_t Ptr Tensor
_self =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::frobenius_norm(
    *$(at::Tensor* _self)));
  }|]

frobenius_norm_tlb
  :: Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
frobenius_norm_tlb :: Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
frobenius_norm_tlb Ptr Tensor
_self Ptr IntArray
_dim CBool
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
frobenius_norm_tl Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
frobenius_norm_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
frobenius_norm_out_ttl Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor -> CBool -> IO (Ptr Tensor)
nuclear_norm_tb Ptr Tensor
_self CBool
_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 :: Ptr Tensor -> IO (Ptr Tensor)
nuclear_norm_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
nuclear_norm_out_ttb Ptr Tensor
_out Ptr Tensor
_self CBool
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nuclear_norm_out_tt Ptr Tensor
_out Ptr Tensor
_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 :: Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
nuclear_norm_tlb Ptr Tensor
_self Ptr IntArray
_dim CBool
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
nuclear_norm_tl Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
nuclear_norm_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
nuclear_norm_out_ttl Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor -> MemoryFormat -> IO (Ptr Tensor)
clone_tM Ptr Tensor
_self MemoryFormat
_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 :: Ptr Tensor -> IO (Ptr Tensor)
clone_t Ptr Tensor
_self =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::clone(
    *$(at::Tensor* _self)));
  }|]

positive_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
positive_t :: Ptr Tensor -> IO (Ptr Tensor)
positive_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> MemoryFormat -> IO (Ptr Tensor)
resize_as__ttM Ptr Tensor
_self Ptr Tensor
_the_template MemoryFormat
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
resize_as__tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
resize_as_sparse__tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> IO (Ptr Tensor)
zero__t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
sub_out_ttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_other Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
sub_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
sub_tts Ptr Tensor
_self Ptr Tensor
_other Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
sub_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
sub_tss Ptr Tensor
_self Ptr Scalar
_other Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
sub_ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
subtract_out_ttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_other Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
subtract_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
subtract_tts Ptr Tensor
_self Ptr Tensor
_other Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
subtract_tt Ptr Tensor
_self Ptr Tensor
_other =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::subtract(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _other)));
  }|]

subtract_tss
  :: Ptr Tensor
  -> Ptr Scalar
  -> Ptr Scalar
  -> IO (Ptr Tensor)
subtract_tss :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
subtract_tss Ptr Tensor
_self Ptr Scalar
_other Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
subtract_ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
rsub_tts Ptr Tensor
_self Ptr Tensor
_other Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
rsub_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
heaviside_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
heaviside_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
rsub_tss Ptr Tensor
_self Ptr Scalar
_other Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
rsub_ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
_sparse_addmm_tttss Ptr Tensor
_self Ptr Tensor
_sparse Ptr Tensor
_dense Ptr Scalar
_beta Ptr Scalar
_alpha =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _sparse)
  , *$(at::Tensor* _dense)
  , *$(at::Scalar* _beta)
  , *$(at::Scalar* _alpha)));
  }|]

_sparse_addmm_ttts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
_sparse_addmm_ttts :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
_sparse_addmm_ttts Ptr Tensor
_self Ptr Tensor
_sparse Ptr Tensor
_dense Ptr Scalar
_beta =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _sparse)
  , *$(at::Tensor* _dense)
  , *$(at::Scalar* _beta)));
  }|]

_sparse_addmm_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_sparse_addmm_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_sparse_addmm_ttt Ptr Tensor
_self Ptr Tensor
_sparse Ptr Tensor
_dense =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _sparse)
  , *$(at::Tensor* _dense)));
  }|]

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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
sparse_sampled_addmm_out_ttttss Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_beta Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> IO (Ptr Tensor)
sparse_sampled_addmm_out_tttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
sparse_sampled_addmm_out_tttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
sparse_sampled_addmm_tttss Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_beta Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
sparse_sampled_addmm_ttts Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
sparse_sampled_addmm_ttt Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_sampled_addmm(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _mat1)
  , *$(at::Tensor* _mat2)));
  }|]

addmm_out_ttttss
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> Ptr Scalar
  -> IO (Ptr Tensor)
addmm_out_ttttss :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
addmm_out_ttttss Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_beta Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> IO (Ptr Tensor)
addmm_out_tttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
addmm_out_tttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
addmm_tttss Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_beta Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
addmm_ttts Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
addmm_ttt Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::addmm(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _mat1)
  , *$(at::Tensor* _mat2)));
  }|]

sparse_csr_tensor_tttlo
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr TensorOptions
  -> IO (Ptr Tensor)
sparse_csr_tensor_tttlo :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr TensorOptions
-> IO (Ptr Tensor)
sparse_csr_tensor_tttlo Ptr Tensor
_crow_indices Ptr Tensor
_col_indices Ptr Tensor
_values Ptr IntArray
_size Ptr TensorOptions
_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_csr_tensor_ttto
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr TensorOptions
  -> IO (Ptr Tensor)
sparse_csr_tensor_ttto :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr TensorOptions -> IO (Ptr Tensor)
sparse_csr_tensor_ttto Ptr Tensor
_crow_indices Ptr Tensor
_col_indices Ptr Tensor
_values Ptr TensorOptions
_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_csr_tensor_unsafe_tttlo
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr TensorOptions
  -> IO (Ptr Tensor)
_sparse_csr_tensor_unsafe_tttlo :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr TensorOptions
-> IO (Ptr Tensor)
_sparse_csr_tensor_unsafe_tttlo Ptr Tensor
_crow_indices Ptr Tensor
_col_indices Ptr Tensor
_values Ptr IntArray
_size Ptr TensorOptions
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_sparse_csr_tensor_unsafe_tttl Ptr Tensor
_crow_indices Ptr Tensor
_col_indices Ptr Tensor
_values Ptr IntArray
_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_coo_tensor_lo
  :: Ptr IntArray
  -> Ptr TensorOptions
  -> IO (Ptr Tensor)
sparse_coo_tensor_lo :: Ptr IntArray -> Ptr TensorOptions -> IO (Ptr Tensor)
sparse_coo_tensor_lo Ptr IntArray
_size Ptr TensorOptions
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr TensorOptions -> IO (Ptr Tensor)
sparse_coo_tensor_tto Ptr Tensor
_indices Ptr Tensor
_values Ptr TensorOptions
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
sparse_coo_tensor_tt Ptr Tensor
_indices Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr TensorOptions
-> IO (Ptr Tensor)
sparse_coo_tensor_ttlo Ptr Tensor
_indices Ptr Tensor
_values Ptr IntArray
_size Ptr TensorOptions
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
sparse_coo_tensor_ttl Ptr Tensor
_indices Ptr Tensor
_values Ptr IntArray
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr TensorOptions
-> IO (Ptr Tensor)
_sparse_coo_tensor_unsafe_ttlo Ptr Tensor
_indices Ptr Tensor
_values Ptr IntArray
_size Ptr TensorOptions
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_sparse_coo_tensor_unsafe_ttl Ptr Tensor
_indices Ptr Tensor
_values Ptr IntArray
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO ()
_validate_sparse_coo_tensor_args_ttl Ptr Tensor
_indices Ptr Tensor
_values Ptr IntArray
_size =
  [C.throwBlock| void {  (at::_validate_sparse_coo_tensor_args(
    *$(at::Tensor* _indices)
  , *$(at::Tensor* _values)
  , *$(std::vector<int64_t>* _size)));
  }|]

_validate_sparse_csr_tensor_args_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> IO (())
_validate_sparse_csr_tensor_args_tttl :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO ()
_validate_sparse_csr_tensor_args_tttl Ptr Tensor
_crow_indices Ptr Tensor
_col_indices Ptr Tensor
_values Ptr IntArray
_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)));
  }|]

_sparse_coo_tensor_with_dims_lllo
  :: Int64
  -> Int64
  -> Ptr IntArray
  -> Ptr TensorOptions
  -> IO (Ptr Tensor)
_sparse_coo_tensor_with_dims_lllo :: Int64
-> Int64 -> Ptr IntArray -> Ptr TensorOptions -> IO (Ptr Tensor)
_sparse_coo_tensor_with_dims_lllo Int64
_sparse_dim Int64
_dense_dim Ptr IntArray
_size Ptr TensorOptions
_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 :: Int64
-> Int64
-> Ptr IntArray
-> Ptr Tensor
-> Ptr Tensor
-> Ptr TensorOptions
-> IO (Ptr Tensor)
_sparse_coo_tensor_with_dims_and_tensors_llltto Int64
_sparse_dim Int64
_dense_dim Ptr IntArray
_size Ptr Tensor
_indices Ptr Tensor
_values Ptr TensorOptions
_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 :: Ptr TensorList -> IO (Ptr TensorList)
_to_cpu_l Ptr TensorList
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
to_dense_backward_tt Ptr Tensor
_grad Ptr Tensor
_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 :: Ptr Tensor -> IO (Ptr Tensor)
_coalesce_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
hspmm_out_ttt Ptr Tensor
_out Ptr Tensor
_mat1 Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
hspmm_tt Ptr Tensor
_mat1 Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
copy_sparse_to_sparse__ttb Ptr Tensor
_self Ptr Tensor
_src CBool
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
copy_sparse_to_sparse__tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Int64 -> IO (Ptr TensorList)
unbind_tl Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> IO (Ptr TensorList)
unbind_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Dimname -> IO (Ptr TensorList)
unbind_tn Ptr Tensor
_self Ptr Dimname
_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_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> IO (Ptr Tensor)
mkldnn_reorder_conv2d_weight_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> IO (Ptr Tensor)
mkldnn_reorder_conv2d_weight_tllll Ptr Tensor
_self Ptr IntArray
_padding Ptr IntArray
_stride Ptr IntArray
_dilation Int64
_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 :: Ptr Tensor
-> Ptr IntArray -> Ptr IntArray -> Ptr IntArray -> IO (Ptr Tensor)
mkldnn_reorder_conv2d_weight_tlll Ptr Tensor
_self Ptr IntArray
_padding Ptr IntArray
_stride Ptr IntArray
_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 :: Ptr Tensor -> Ptr IntArray -> Ptr IntArray -> IO (Ptr Tensor)
mkldnn_reorder_conv2d_weight_tll Ptr Tensor
_self Ptr IntArray
_padding Ptr IntArray
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
mkldnn_reorder_conv2d_weight_tl Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor -> IO (Ptr Tensor)
mkldnn_reorder_conv2d_weight_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> IO (Ptr Tensor)
mkldnn_reorder_conv3d_weight_tllll Ptr Tensor
_self Ptr IntArray
_padding Ptr IntArray
_stride Ptr IntArray
_dilation Int64
_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 :: Ptr Tensor
-> Ptr IntArray -> Ptr IntArray -> Ptr IntArray -> IO (Ptr Tensor)
mkldnn_reorder_conv3d_weight_tlll Ptr Tensor
_self Ptr IntArray
_padding Ptr IntArray
_stride Ptr IntArray
_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 :: Ptr Tensor -> Ptr IntArray -> Ptr IntArray -> IO (Ptr Tensor)
mkldnn_reorder_conv3d_weight_tll Ptr Tensor
_self Ptr IntArray
_padding Ptr IntArray
_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 :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
mkldnn_reorder_conv3d_weight_tl Ptr Tensor
_self Ptr IntArray
_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 :: Ptr Tensor -> IO (Ptr Tensor)
mkldnn_reorder_conv3d_weight_t Ptr Tensor
_self =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_reorder_conv3d_weight(
    *$(at::Tensor* _self)));
  }|]