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


_foreach_reciprocal_l
  :: Ptr TensorList
  -> IO (Ptr TensorList)
_foreach_reciprocal_l :: Ptr TensorList -> IO (Ptr TensorList)
_foreach_reciprocal_l Ptr TensorList
_tensors =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_reciprocal(
    *$(std::vector<at::Tensor>* _tensors)));
  }|]

_foreach_reciprocal__l
  :: Ptr TensorList
  -> IO (())
_foreach_reciprocal__l :: Ptr TensorList -> IO ()
_foreach_reciprocal__l Ptr TensorList
_self =
  [C.throwBlock| void {  (at::_foreach_reciprocal_(
    *$(std::vector<at::Tensor>* _self)));
  }|]

_foreach_sigmoid_l
  :: Ptr TensorList
  -> IO (Ptr TensorList)
_foreach_sigmoid_l :: Ptr TensorList -> IO (Ptr TensorList)
_foreach_sigmoid_l Ptr TensorList
_tensors =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_sigmoid(
    *$(std::vector<at::Tensor>* _tensors)));
  }|]

_foreach_sigmoid__l
  :: Ptr TensorList
  -> IO (())
_foreach_sigmoid__l :: Ptr TensorList -> IO ()
_foreach_sigmoid__l Ptr TensorList
_self =
  [C.throwBlock| void {  (at::_foreach_sigmoid_(
    *$(std::vector<at::Tensor>* _self)));
  }|]

_foreach_trunc_l
  :: Ptr TensorList
  -> IO (Ptr TensorList)
_foreach_trunc_l :: Ptr TensorList -> IO (Ptr TensorList)
_foreach_trunc_l Ptr TensorList
_tensors =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_trunc(
    *$(std::vector<at::Tensor>* _tensors)));
  }|]

_foreach_trunc__l
  :: Ptr TensorList
  -> IO (())
_foreach_trunc__l :: Ptr TensorList -> IO ()
_foreach_trunc__l Ptr TensorList
_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 :: Ptr TensorList
-> Ptr TensorList -> Ptr TensorList -> Ptr Scalar -> IO ()
_foreach_addcdiv__llls Ptr TensorList
_self Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 Ptr Scalar
_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 :: Ptr TensorList -> Ptr TensorList -> Ptr TensorList -> IO ()
_foreach_addcdiv__lll Ptr TensorList
_self Ptr TensorList
_tensor1 Ptr TensorList
_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 :: Ptr TensorList
-> Ptr TensorList -> Ptr TensorList -> Ptr Scalar -> IO ()
_foreach_addcmul__llls Ptr TensorList
_self Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 Ptr Scalar
_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 :: Ptr TensorList -> Ptr TensorList -> Ptr TensorList -> IO ()
_foreach_addcmul__lll Ptr TensorList
_self Ptr TensorList
_tensor1 Ptr TensorList
_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 :: Ptr TensorList
-> Ptr TensorList
-> Ptr TensorList
-> Ptr (StdVector Scalar)
-> IO ()
_foreach_addcdiv__lllA Ptr TensorList
_self Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 Ptr (StdVector Scalar)
_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_addcmul__lllA
  :: Ptr TensorList
  -> Ptr TensorList
  -> Ptr TensorList
  -> Ptr (StdVector Scalar)
  -> IO (())
_foreach_addcmul__lllA :: Ptr TensorList
-> Ptr TensorList
-> Ptr TensorList
-> Ptr (StdVector Scalar)
-> IO ()
_foreach_addcmul__lllA Ptr TensorList
_self Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 Ptr (StdVector Scalar)
_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_addcdiv_llls
  :: Ptr TensorList
  -> Ptr TensorList
  -> Ptr TensorList
  -> Ptr Scalar
  -> IO (Ptr TensorList)
_foreach_addcdiv_llls :: Ptr TensorList
-> Ptr TensorList
-> Ptr TensorList
-> Ptr Scalar
-> IO (Ptr TensorList)
_foreach_addcdiv_llls Ptr TensorList
_input Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 Ptr Scalar
_value =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcdiv(
    *$(std::vector<at::Tensor>* _input)
  , *$(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 :: Ptr TensorList
-> Ptr TensorList -> Ptr TensorList -> IO (Ptr TensorList)
_foreach_addcdiv_lll Ptr TensorList
_input Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcdiv(
    *$(std::vector<at::Tensor>* _input)
  , *$(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 :: Ptr TensorList
-> Ptr TensorList
-> Ptr TensorList
-> Ptr Scalar
-> IO (Ptr TensorList)
_foreach_addcmul_llls Ptr TensorList
_input Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 Ptr Scalar
_value =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcmul(
    *$(std::vector<at::Tensor>* _input)
  , *$(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 :: Ptr TensorList
-> Ptr TensorList -> Ptr TensorList -> IO (Ptr TensorList)
_foreach_addcmul_lll Ptr TensorList
_input Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcmul(
    *$(std::vector<at::Tensor>* _input)
  , *$(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 :: Ptr TensorList
-> Ptr TensorList
-> Ptr TensorList
-> Ptr (StdVector Scalar)
-> IO (Ptr TensorList)
_foreach_addcdiv_lllA Ptr TensorList
_input Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 Ptr (StdVector Scalar)
_scalars =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcdiv(
    *$(std::vector<at::Tensor>* _input)
  , *$(std::vector<at::Tensor>* _tensor1)
  , *$(std::vector<at::Tensor>* _tensor2)
  , *$(std::vector<at::Scalar>* _scalars)));
  }|]

_foreach_addcmul_lllA
  :: Ptr TensorList
  -> Ptr TensorList
  -> Ptr TensorList
  -> Ptr (StdVector Scalar)
  -> IO (Ptr TensorList)
_foreach_addcmul_lllA :: Ptr TensorList
-> Ptr TensorList
-> Ptr TensorList
-> Ptr (StdVector Scalar)
-> IO (Ptr TensorList)
_foreach_addcmul_lllA Ptr TensorList
_input Ptr TensorList
_tensor1 Ptr TensorList
_tensor2 Ptr (StdVector Scalar)
_scalars =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_addcmul(
    *$(std::vector<at::Tensor>* _input)
  , *$(std::vector<at::Tensor>* _tensor1)
  , *$(std::vector<at::Tensor>* _tensor2)
  , *$(std::vector<at::Scalar>* _scalars)));
  }|]

_foreach_maximum_ll
  :: Ptr TensorList
  -> Ptr TensorList
  -> IO (Ptr TensorList)
_foreach_maximum_ll :: Ptr TensorList -> Ptr TensorList -> IO (Ptr TensorList)
_foreach_maximum_ll Ptr TensorList
_tensors1 Ptr TensorList
_tensors2 =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_maximum(
    *$(std::vector<at::Tensor>* _tensors1)
  , *$(std::vector<at::Tensor>* _tensors2)));
  }|]

_foreach_minimum_ll
  :: Ptr TensorList
  -> Ptr TensorList
  -> IO (Ptr TensorList)
_foreach_minimum_ll :: Ptr TensorList -> Ptr TensorList -> IO (Ptr TensorList)
_foreach_minimum_ll Ptr TensorList
_tensors1 Ptr TensorList
_tensors2 =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_minimum(
    *$(std::vector<at::Tensor>* _tensors1)
  , *$(std::vector<at::Tensor>* _tensors2)));
  }|]

_foreach_norm_ls
  :: Ptr TensorList
  -> Ptr Scalar
  -> IO (Ptr TensorList)
_foreach_norm_ls :: Ptr TensorList -> Ptr Scalar -> IO (Ptr TensorList)
_foreach_norm_ls Ptr TensorList
_tensors Ptr Scalar
_ord =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_norm(
    *$(std::vector<at::Tensor>* _tensors)
  , *$(at::Scalar* _ord)));
  }|]

_foreach_norm_l
  :: Ptr TensorList
  -> IO (Ptr TensorList)
_foreach_norm_l :: Ptr TensorList -> IO (Ptr TensorList)
_foreach_norm_l Ptr TensorList
_tensors =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::_foreach_norm(
    *$(std::vector<at::Tensor>* _tensors)));
  }|]

bucketize_ttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr Tensor)
bucketize_ttbb :: Ptr Tensor -> Ptr Tensor -> CBool -> CBool -> IO (Ptr Tensor)
bucketize_ttbb Ptr Tensor
_self Ptr Tensor
_boundaries CBool
_out_int32 CBool
_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 :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
bucketize_ttb Ptr Tensor
_self Ptr Tensor
_boundaries CBool
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
bucketize_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> CBool -> CBool -> IO (Ptr Tensor)
bucketize_out_tttbb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_boundaries CBool
_out_int32 CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
bucketize_out_tttb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_boundaries CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
bucketize_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Scalar -> Ptr Tensor -> CBool -> CBool -> IO (Ptr Tensor)
bucketize_stbb Ptr Scalar
_self Ptr Tensor
_boundaries CBool
_out_int32 CBool
_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 :: Ptr Scalar -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
bucketize_stb Ptr Scalar
_self Ptr Tensor
_boundaries CBool
_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 :: Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
bucketize_st Ptr Scalar
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> Ptr StdString
-> Ptr Tensor
-> IO (Ptr Tensor)
searchsorted_ttbbst Ptr Tensor
_sorted_sequence Ptr Tensor
_self CBool
_out_int32 CBool
_right Ptr StdString
_side Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> CBool -> CBool -> Ptr StdString -> IO (Ptr Tensor)
searchsorted_ttbbs Ptr Tensor
_sorted_sequence Ptr Tensor
_self CBool
_out_int32 CBool
_right Ptr StdString
_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 :: Ptr Tensor -> Ptr Tensor -> CBool -> CBool -> IO (Ptr Tensor)
searchsorted_ttbb Ptr Tensor
_sorted_sequence Ptr Tensor
_self CBool
_out_int32 CBool
_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 :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
searchsorted_ttb Ptr Tensor
_sorted_sequence Ptr Tensor
_self CBool
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
searchsorted_tt Ptr Tensor
_sorted_sequence Ptr Tensor
_self =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::searchsorted(
    *$(at::Tensor* _sorted_sequence)
  , *$(at::Tensor* _self)));
  }|]

_torch_cuda_cu_linker_symbol_op_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
_torch_cuda_cu_linker_symbol_op_t :: Ptr Tensor -> IO (Ptr Tensor)
_torch_cuda_cu_linker_symbol_op_t Ptr Tensor
_self =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_torch_cuda_cu_linker_symbol_op(
    *$(at::Tensor* _self)));
  }|]

searchsorted_out_tttbbst
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> Ptr StdString
  -> Ptr Tensor
  -> IO (Ptr Tensor)
searchsorted_out_tttbbst :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> Ptr StdString
-> Ptr Tensor
-> IO (Ptr Tensor)
searchsorted_out_tttbbst Ptr Tensor
_out Ptr Tensor
_sorted_sequence Ptr Tensor
_self CBool
_out_int32 CBool
_right Ptr StdString
_side Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> Ptr StdString
-> IO (Ptr Tensor)
searchsorted_out_tttbbs Ptr Tensor
_out Ptr Tensor
_sorted_sequence Ptr Tensor
_self CBool
_out_int32 CBool
_right Ptr StdString
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> CBool -> CBool -> IO (Ptr Tensor)
searchsorted_out_tttbb Ptr Tensor
_out Ptr Tensor
_sorted_sequence Ptr Tensor
_self CBool
_out_int32 CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
searchsorted_out_tttb Ptr Tensor
_out Ptr Tensor
_sorted_sequence Ptr Tensor
_self CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
searchsorted_out_ttt Ptr Tensor
_out Ptr Tensor
_sorted_sequence Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Scalar
-> CBool
-> CBool
-> Ptr StdString
-> Ptr Tensor
-> IO (Ptr Tensor)
searchsorted_tsbbst Ptr Tensor
_sorted_sequence Ptr Scalar
_self CBool
_out_int32 CBool
_right Ptr StdString
_side Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Scalar -> CBool -> CBool -> Ptr StdString -> IO (Ptr Tensor)
searchsorted_tsbbs Ptr Tensor
_sorted_sequence Ptr Scalar
_self CBool
_out_int32 CBool
_right Ptr StdString
_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 :: Ptr Tensor -> Ptr Scalar -> CBool -> CBool -> IO (Ptr Tensor)
searchsorted_tsbb Ptr Tensor
_sorted_sequence Ptr Scalar
_self CBool
_out_int32 CBool
_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 :: Ptr Tensor -> Ptr Scalar -> CBool -> IO (Ptr Tensor)
searchsorted_tsb Ptr Tensor
_sorted_sequence Ptr Scalar
_self CBool
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
searchsorted_ts Ptr Tensor
_sorted_sequence Ptr Scalar
_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 :: Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
_convert_indices_from_coo_to_csr_tlb Ptr Tensor
_self Int64
_size CBool
_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 :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
_convert_indices_from_coo_to_csr_tl Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
_convert_indices_from_coo_to_csr_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Int64
_size CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
_convert_indices_from_coo_to_csr_out_ttl Ptr Tensor
_out Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> Ptr Tensor -> CBool -> CBool -> IO (Ptr Tensor)
_convert_indices_from_csr_to_coo_ttbb Ptr Tensor
_crow_indices Ptr Tensor
_col_indices CBool
_out_int32 CBool
_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 :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
_convert_indices_from_csr_to_coo_ttb Ptr Tensor
_crow_indices Ptr Tensor
_col_indices CBool
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_convert_indices_from_csr_to_coo_tt Ptr Tensor
_crow_indices Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> CBool -> CBool -> IO (Ptr Tensor)
_convert_indices_from_csr_to_coo_out_tttbb Ptr Tensor
_out Ptr Tensor
_crow_indices Ptr Tensor
_col_indices CBool
_out_int32 CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
_convert_indices_from_csr_to_coo_out_tttb Ptr Tensor
_out Ptr Tensor
_crow_indices Ptr Tensor
_col_indices CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_convert_indices_from_csr_to_coo_out_ttt Ptr Tensor
_out Ptr Tensor
_crow_indices Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
mse_loss_out_tttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
mse_loss_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
mse_loss_ttl Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
mse_loss_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
mse_loss_backward_out_ttttl Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
mse_loss_backward_tttl Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_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_out_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
l1_loss_out_tttl :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
l1_loss_out_tttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::l1_loss_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _target)
  , $(int64_t _reduction)));
  }|]

l1_loss_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
l1_loss_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
l1_loss_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::l1_loss_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _target)));
  }|]

l1_loss_ttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
l1_loss_ttl :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
l1_loss_ttl Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
l1_loss_tt Ptr Tensor
_self Ptr Tensor
_target =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::l1_loss(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _target)));
  }|]

l1_loss_backward_out_ttttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
l1_loss_backward_out_ttttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
l1_loss_backward_out_ttttl Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::l1_loss_backward_out(
    *$(at::Tensor* _grad_input)
  , *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _target)
  , $(int64_t _reduction)));
  }|]

l1_loss_backward_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
l1_loss_backward_tttl :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
l1_loss_backward_tttl Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::l1_loss_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _target)
  , $(int64_t _reduction)));
  }|]

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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
multi_margin_loss_out_tttsstl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_margin Ptr Tensor
_weight Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Tensor
-> IO (Ptr Tensor)
multi_margin_loss_out_tttsst Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_margin Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
multi_margin_loss_out_tttss Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
multi_margin_loss_out_ttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
multi_margin_loss_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
multi_margin_loss_ttsstl Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_margin Ptr Tensor
_weight Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Tensor
-> IO (Ptr Tensor)
multi_margin_loss_ttsst Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_margin Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
multi_margin_loss_ttss Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
multi_margin_loss_tts Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
multi_margin_loss_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
multi_margin_loss_backward_out_ttttsstl Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_margin Ptr Tensor
_weight Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Tensor
-> IO (Ptr Tensor)
multi_margin_loss_backward_out_ttttsst Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_margin Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
multi_margin_loss_backward_out_ttttss Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
multi_margin_loss_backward_tttsstl Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_margin Ptr Tensor
_weight Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Tensor
-> IO (Ptr Tensor)
multi_margin_loss_backward_tttsst Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_margin Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
multi_margin_loss_backward_tttss Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Scalar
_p Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
multilabel_margin_loss_out_tttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
multilabel_margin_loss_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
multilabel_margin_loss_ttl Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
multilabel_margin_loss_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
multilabel_margin_loss_forward_out_ttttl Ptr Tensor
_output Ptr Tensor
_is_target Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor
-> Ptr Tensor -> Int64 -> IO (Ptr (StdTuple '(Tensor, Tensor)))
multilabel_margin_loss_forward_ttl Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Ptr Tensor
-> IO (Ptr Tensor)
multilabel_margin_loss_backward_out_ttttlt Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Ptr Tensor
-> IO (Ptr Tensor)
multilabel_margin_loss_backward_tttlt Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr Tensor)
nll_loss_out_ttttll Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
nll_loss_out_ttttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss_out_tttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
nll_loss_nd_tttll Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
nll_loss_nd_tttl Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss_nd_ttt Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss_nd_tt Ptr Tensor
_self Ptr Tensor
_target =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nll_loss_nd(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _target)));
  }|]

nll_loss_tttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
nll_loss_tttll :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
nll_loss_tttll Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
nll_loss_tttl Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss_ttt Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
nll_loss_forward_out_tttttll Ptr Tensor
_output Ptr Tensor
_total_weight Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
nll_loss_forward_tttll Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> IO (Ptr Tensor)
nll_loss_backward_out_tttttllt Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_ignore_index Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> IO (Ptr Tensor)
nll_loss_backward_ttttllt Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_ignore_index Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr Tensor)
nll_loss2d_out_ttttll Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
nll_loss2d_out_ttttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss2d_out_tttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss2d_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
nll_loss2d_tttll Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
nll_loss2d_tttl Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss2d_ttt Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
nll_loss2d_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
nll_loss2d_forward_out_tttttll Ptr Tensor
_output Ptr Tensor
_total_weight Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
nll_loss2d_forward_tttll Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> IO (Ptr Tensor)
nll_loss2d_backward_out_tttttllt Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_ignore_index Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> IO (Ptr Tensor)
nll_loss2d_backward_ttttllt Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Ptr Tensor
_weight Int64
_reduction Int64
_ignore_index Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> CDouble -> IO (Ptr Tensor)
smooth_l1_loss_out_tttld Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction CDouble
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
smooth_l1_loss_out_tttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
smooth_l1_loss_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> CDouble -> IO (Ptr Tensor)
smooth_l1_loss_ttld Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction CDouble
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
smooth_l1_loss_ttl Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
smooth_l1_loss_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CDouble
-> IO (Ptr Tensor)
smooth_l1_loss_backward_out_ttttld Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction CDouble
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> CDouble -> IO (Ptr Tensor)
smooth_l1_loss_backward_tttld Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction CDouble
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> CDouble -> IO (Ptr Tensor)
huber_loss_out_tttld Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction CDouble
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
huber_loss_out_tttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
huber_loss_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> CDouble -> IO (Ptr Tensor)
huber_loss_ttld Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction CDouble
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
huber_loss_ttl Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
huber_loss_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CDouble
-> IO (Ptr Tensor)
huber_loss_backward_out_ttttld Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction CDouble
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> CDouble -> IO (Ptr Tensor)
huber_loss_backward_tttld Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_reduction CDouble
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
soft_margin_loss_out_tttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
soft_margin_loss_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
soft_margin_loss_ttl Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
soft_margin_loss_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
soft_margin_loss_backward_out_ttttl Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
soft_margin_loss_backward_tttl Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_target Int64
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
elu_out_ttsss Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_alpha Ptr Scalar
_scale Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
elu_out_ttss Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_alpha Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
elu_out_tts Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
elu_out_tt Ptr Tensor
_out Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Scalar -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
elu_tsss Ptr Tensor
_self Ptr Scalar
_alpha Ptr Scalar
_scale Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
elu_tss Ptr Tensor
_self Ptr Scalar
_alpha Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
elu_ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr Tensor)
elu_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> Ptr Tensor
-> IO (Ptr Tensor)
elu_backward_out_ttsssbt Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Scalar
_alpha Ptr Scalar
_scale Ptr Scalar
_input_scale CBool
_is_result Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> Ptr Tensor
-> IO (Ptr Tensor)
elu_backward_tsssbt Ptr Tensor
_grad_output Ptr Scalar
_alpha Ptr Scalar
_scale Ptr Scalar
_input_scale CBool
_is_result Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Scalar -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
elu__tsss Ptr Tensor
_self Ptr Scalar
_alpha Ptr Scalar
_scale Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
elu__tss Ptr Tensor
_self Ptr Scalar
_alpha Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
elu__ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr Tensor)
elu__t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
glu_out_ttl Ptr Tensor
_out Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
glu_out_tt Ptr Tensor
_out Ptr Tensor
_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 :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
glu_tl Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> IO (Ptr Tensor)
glu_t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
glu_backward_out_tttl Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Int64
_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 :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
glu_backward_ttl Ptr Tensor
_grad_output Ptr Tensor
_self Int64
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::glu_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

hardsigmoid_out_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
hardsigmoid_out_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
hardsigmoid_out_tt Ptr Tensor
_out Ptr Tensor
_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 :: Ptr Tensor -> IO (Ptr Tensor)
hardsigmoid_t Ptr Tensor
_self =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardsigmoid(
    *$(at::Tensor* _self)));
  }|]

hardsigmoid__t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
hardsigmoid__t :: Ptr Tensor -> IO (Ptr Tensor)
hardsigmoid__t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
hardsigmoid_backward_out_ttt Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
hardsigmoid_backward_tt Ptr Tensor
_grad_output Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
hardtanh_out_ttss Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_min_val Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
hardtanh_out_tts Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
hardtanh_out_tt Ptr Tensor
_out Ptr Tensor
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
hardtanh_tss Ptr Tensor
_self Ptr Scalar
_min_val Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
hardtanh_ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr Tensor)
hardtanh_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
hardtanh_backward_out_tttss Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Scalar
_min_val Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
hardtanh_backward_ttss Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Scalar
_min_val Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
hardtanh__tss Ptr Tensor
_self Ptr Scalar
_min_val Ptr Scalar
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
hardtanh__ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr Tensor)
hardtanh__t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
hardswish_out_tt Ptr Tensor
_out Ptr Tensor
_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 :: Ptr Tensor -> IO (Ptr Tensor)
hardswish_t Ptr Tensor
_self =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::hardswish(
    *$(at::Tensor* _self)));
  }|]

hardswish__t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
hardswish__t :: Ptr Tensor -> IO (Ptr Tensor)
hardswish__t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
hardswish_backward_tt Ptr Tensor
_grad_output Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
leaky_relu_out_tts Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
leaky_relu_out_tt Ptr Tensor
_out Ptr Tensor
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
leaky_relu_ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr Tensor)
leaky_relu_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> CBool
-> IO (Ptr Tensor)
leaky_relu_backward_out_tttsb Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Scalar
_negative_slope CBool
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> CBool -> IO (Ptr Tensor)
leaky_relu_backward_ttsb Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Scalar
_negative_slope CBool
_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 :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
leaky_relu__ts Ptr Tensor
_self Ptr Scalar
_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 :: Ptr Tensor -> IO (Ptr Tensor)
leaky_relu__t Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
log_sigmoid_out_tt Ptr Tensor
_out Ptr Tensor
_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 :: Ptr Tensor -> IO (Ptr Tensor)
log_sigmoid_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
log_sigmoid_forward_out_ttt Ptr Tensor
_output Ptr Tensor
_buffer Ptr Tensor
_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 :: Ptr Tensor -> IO (Ptr (StdTuple '(Tensor, Tensor)))
log_sigmoid_forward_t Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
log_sigmoid_backward_out_tttt Ptr Tensor
_grad_input Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
log_sigmoid_backward_ttt Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> Ptr Generator
-> IO (Ptr Tensor)
rrelu_with_noise_out_tttssbG Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_upper CBool
_training Ptr Generator
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> IO (Ptr Tensor)
rrelu_with_noise_out_tttssb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_upper CBool
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
rrelu_with_noise_out_tttss Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
rrelu_with_noise_out_ttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
rrelu_with_noise_out_ttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> Ptr Generator
-> IO (Ptr Tensor)
rrelu_with_noise_ttssbG Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_upper CBool
_training Ptr Generator
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> IO (Ptr Tensor)
rrelu_with_noise_ttssb Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_upper CBool
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
rrelu_with_noise_ttss Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
rrelu_with_noise_tts Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
rrelu_with_noise_tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> CBool
-> IO (Ptr Tensor)
rrelu_with_noise_backward_tttssbb Ptr Tensor
_grad_output Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_upper CBool
_training CBool
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> Ptr Generator
-> IO (Ptr Tensor)
rrelu_with_noise__ttssbG Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_upper CBool
_training Ptr Generator
_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 :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> CBool
-> IO (Ptr Tensor)
rrelu_with_noise__ttssb Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_upper CBool
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
rrelu_with_noise__ttss Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_lower Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
rrelu_with_noise__tts Ptr Tensor
_self Ptr Tensor
_noise Ptr Scalar
_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 :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
rrelu_with_noise__tt Ptr Tensor
_self Ptr Tensor
_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 :: Ptr Tensor
-> Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> IO (Ptr Tensor)
softplus_out_ttss Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_beta Ptr Scalar
_threshold =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::softplus_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Scalar* _beta)
  , *$(at::Scalar* _threshold)));
  }|]