-- generated by using spec/Declarations.yaml

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}

module Torch.Internal.Unmanaged.Native.Native12 where


import Foreign.C.String
import Foreign.C.Types
import Foreign
import Torch.Internal.Type

import qualified Language.C.Inline.Cpp as C
import qualified Language.C.Inline.Cpp.Unsafe as C
import qualified Language.C.Inline.Context as C
import qualified Language.C.Types as C

C.context $ C.cppCtx <> mempty { C.ctxTypesTable = typeTable }

C.include "<vector>"
C.include "<ATen/Tensor.h>"
C.include "<ATen/Functions.h>"


_linalg_svd_out_ttttbbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> Ptr StdString
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_linalg_svd_out_ttttbbs :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> Ptr StdString
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_linalg_svd_out_ttttbbs Ptr Tensor
_U Ptr Tensor
_S Ptr Tensor
_Vh Ptr Tensor
_A CBool
_full_matrices CBool
_compute_uv Ptr StdString
_driver =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd_out(
    *$(at::Tensor* _U)
  , *$(at::Tensor* _S)
  , *$(at::Tensor* _Vh)
  , *$(at::Tensor* _A)
  , $(bool _full_matrices)
  , $(bool _compute_uv)
  , *$(std::string* _driver)));
  }|]

_linalg_svd_out_ttttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_linalg_svd_out_ttttbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_linalg_svd_out_ttttbb Ptr Tensor
_U Ptr Tensor
_S Ptr Tensor
_Vh Ptr Tensor
_A CBool
_full_matrices CBool
_compute_uv =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd_out(
    *$(at::Tensor* _U)
  , *$(at::Tensor* _S)
  , *$(at::Tensor* _Vh)
  , *$(at::Tensor* _A)
  , $(bool _full_matrices)
  , $(bool _compute_uv)));
  }|]

_linalg_svd_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_linalg_svd_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_linalg_svd_out_ttttb Ptr Tensor
_U Ptr Tensor
_S Ptr Tensor
_Vh Ptr Tensor
_A CBool
_full_matrices =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd_out(
    *$(at::Tensor* _U)
  , *$(at::Tensor* _S)
  , *$(at::Tensor* _Vh)
  , *$(at::Tensor* _A)
  , $(bool _full_matrices)));
  }|]

_linalg_svd_out_tttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_linalg_svd_out_tttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_linalg_svd_out_tttt Ptr Tensor
_U Ptr Tensor
_S Ptr Tensor
_Vh Ptr Tensor
_A =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_linalg_svd_out(
    *$(at::Tensor* _U)
  , *$(at::Tensor* _S)
  , *$(at::Tensor* _Vh)
  , *$(at::Tensor* _A)));
  }|]

linalg_svd_tbs
  :: Ptr Tensor
  -> CBool
  -> Ptr StdString
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
linalg_svd_tbs :: Ptr Tensor
-> CBool
-> Ptr StdString
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
linalg_svd_tbs Ptr Tensor
_A CBool
_full_matrices Ptr StdString
_driver =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd(
    *$(at::Tensor* _A)
  , $(bool _full_matrices)
  , *$(std::string* _driver)));
  }|]

linalg_svd_tb
  :: Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
linalg_svd_tb :: Ptr Tensor
-> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
linalg_svd_tb Ptr Tensor
_A CBool
_full_matrices =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd(
    *$(at::Tensor* _A)
  , $(bool _full_matrices)));
  }|]

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

linalg_svd_out_ttttbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> Ptr StdString
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
linalg_svd_out_ttttbs :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> Ptr StdString
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
linalg_svd_out_ttttbs Ptr Tensor
_U Ptr Tensor
_S Ptr Tensor
_Vh Ptr Tensor
_A CBool
_full_matrices Ptr StdString
_driver =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd_out(
    *$(at::Tensor* _U)
  , *$(at::Tensor* _S)
  , *$(at::Tensor* _Vh)
  , *$(at::Tensor* _A)
  , $(bool _full_matrices)
  , *$(std::string* _driver)));
  }|]

linalg_svd_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
linalg_svd_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
linalg_svd_out_ttttb Ptr Tensor
_U Ptr Tensor
_S Ptr Tensor
_Vh Ptr Tensor
_A CBool
_full_matrices =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd_out(
    *$(at::Tensor* _U)
  , *$(at::Tensor* _S)
  , *$(at::Tensor* _Vh)
  , *$(at::Tensor* _A)
  , $(bool _full_matrices)));
  }|]

linalg_svd_out_tttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
linalg_svd_out_tttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
linalg_svd_out_tttt Ptr Tensor
_U Ptr Tensor
_S Ptr Tensor
_Vh Ptr Tensor
_A =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::linalg_svd_out(
    *$(at::Tensor* _U)
  , *$(at::Tensor* _S)
  , *$(at::Tensor* _Vh)
  , *$(at::Tensor* _A)));
  }|]

linalg_svdvals_ts
  :: Ptr Tensor
  -> Ptr StdString
  -> IO (Ptr Tensor)
linalg_svdvals_ts :: Ptr Tensor -> Ptr StdString -> IO (Ptr Tensor)
linalg_svdvals_ts Ptr Tensor
_A Ptr StdString
_driver =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_svdvals(
    *$(at::Tensor* _A)
  , *$(std::string* _driver)));
  }|]

linalg_svdvals_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
linalg_svdvals_t :: Ptr Tensor -> IO (Ptr Tensor)
linalg_svdvals_t Ptr Tensor
_A =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_svdvals(
    *$(at::Tensor* _A)));
  }|]

linalg_svdvals_out_tts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr StdString
  -> IO (Ptr Tensor)
linalg_svdvals_out_tts :: Ptr Tensor -> Ptr Tensor -> Ptr StdString -> IO (Ptr Tensor)
linalg_svdvals_out_tts Ptr Tensor
_out Ptr Tensor
_A Ptr StdString
_driver =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_svdvals_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _A)
  , *$(std::string* _driver)));
  }|]

linalg_svdvals_out_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_svdvals_out_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_svdvals_out_tt Ptr Tensor
_out Ptr Tensor
_A =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_svdvals_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _A)));
  }|]

linalg_cond_ts
  :: Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
linalg_cond_ts :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
linalg_cond_ts Ptr Tensor
_self Ptr Scalar
_p =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cond(
    *$(at::Tensor* _self)
  , *$(at::Scalar* _p)));
  }|]

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

linalg_cond_out_tts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
linalg_cond_out_tts :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
linalg_cond_out_tts Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_p =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_cond_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Scalar* _p)));
  }|]

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

linalg_pinv_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_pinv_tttb :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
linalg_pinv_tttb Ptr Tensor
_self Ptr Tensor
_atol Ptr Tensor
_rtol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _atol)
  , *$(at::Tensor* _rtol)
  , $(bool _hermitian)));
  }|]

linalg_pinv_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_pinv_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_pinv_ttt Ptr Tensor
_self Ptr Tensor
_atol Ptr Tensor
_rtol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _atol)
  , *$(at::Tensor* _rtol)));
  }|]

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

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

linalg_pinv_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_pinv_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr Tensor)
linalg_pinv_out_ttttb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_atol Ptr Tensor
_rtol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _atol)
  , *$(at::Tensor* _rtol)
  , $(bool _hermitian)));
  }|]

linalg_pinv_out_tttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_pinv_out_tttt :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_pinv_out_tttt Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_atol Ptr Tensor
_rtol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _atol)
  , *$(at::Tensor* _rtol)));
  }|]

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

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

linalg_pinv_tddb
  :: Ptr Tensor
  -> CDouble
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
linalg_pinv_tddb :: Ptr Tensor -> CDouble -> CDouble -> CBool -> IO (Ptr Tensor)
linalg_pinv_tddb Ptr Tensor
_self CDouble
_atol CDouble
_rtol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
    *$(at::Tensor* _self)
  , $(double _atol)
  , $(double _rtol)
  , $(bool _hermitian)));
  }|]

linalg_pinv_tdd
  :: Ptr Tensor
  -> CDouble
  -> CDouble
  -> IO (Ptr Tensor)
linalg_pinv_tdd :: Ptr Tensor -> CDouble -> CDouble -> IO (Ptr Tensor)
linalg_pinv_tdd Ptr Tensor
_self CDouble
_atol CDouble
_rtol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
    *$(at::Tensor* _self)
  , $(double _atol)
  , $(double _rtol)));
  }|]

linalg_pinv_td
  :: Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
linalg_pinv_td :: Ptr Tensor -> CDouble -> IO (Ptr Tensor)
linalg_pinv_td Ptr Tensor
_self CDouble
_atol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
    *$(at::Tensor* _self)
  , $(double _atol)));
  }|]

linalg_pinv_out_ttddb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
linalg_pinv_out_ttddb :: Ptr Tensor
-> Ptr Tensor -> CDouble -> CDouble -> CBool -> IO (Ptr Tensor)
linalg_pinv_out_ttddb Ptr Tensor
_out Ptr Tensor
_self CDouble
_atol CDouble
_rtol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _atol)
  , $(double _rtol)
  , $(bool _hermitian)));
  }|]

linalg_pinv_out_ttdd
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CDouble
  -> IO (Ptr Tensor)
linalg_pinv_out_ttdd :: Ptr Tensor -> Ptr Tensor -> CDouble -> CDouble -> IO (Ptr Tensor)
linalg_pinv_out_ttdd Ptr Tensor
_out Ptr Tensor
_self CDouble
_atol CDouble
_rtol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _atol)
  , $(double _rtol)));
  }|]

linalg_pinv_out_ttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
linalg_pinv_out_ttd :: Ptr Tensor -> Ptr Tensor -> CDouble -> IO (Ptr Tensor)
linalg_pinv_out_ttd Ptr Tensor
_out Ptr Tensor
_self CDouble
_atol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _atol)));
  }|]

linalg_pinv_tdb
  :: Ptr Tensor
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
linalg_pinv_tdb :: Ptr Tensor -> CDouble -> CBool -> IO (Ptr Tensor)
linalg_pinv_tdb Ptr Tensor
_self CDouble
_rcond CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
    *$(at::Tensor* _self)
  , $(double _rcond)
  , $(bool _hermitian)));
  }|]

linalg_pinv_ttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_pinv_ttb :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
linalg_pinv_ttb Ptr Tensor
_self Ptr Tensor
_rcond CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _rcond)
  , $(bool _hermitian)));
  }|]

linalg_pinv_out_ttdb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
linalg_pinv_out_ttdb :: Ptr Tensor -> Ptr Tensor -> CDouble -> CBool -> IO (Ptr Tensor)
linalg_pinv_out_ttdb Ptr Tensor
_out Ptr Tensor
_self CDouble
_rcond CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _rcond)
  , $(bool _hermitian)));
  }|]

linalg_pinv_out_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_pinv_out_tttb :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
linalg_pinv_out_tttb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_rcond CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_pinv_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _rcond)
  , $(bool _hermitian)));
  }|]

_linalg_solve_ex_ttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
_linalg_solve_ex_ttbb :: Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor)))
_linalg_solve_ex_ttbb Ptr Tensor
_A Ptr Tensor
_B CBool
_left CBool
_check_errors =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_linalg_solve_ex(
    *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)
  , $(bool _check_errors)));
  }|]

_linalg_solve_ex_ttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
_linalg_solve_ex_ttb :: Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor)))
_linalg_solve_ex_ttb Ptr Tensor
_A Ptr Tensor
_B CBool
_left =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_linalg_solve_ex(
    *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)));
  }|]

_linalg_solve_ex_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
_linalg_solve_ex_tt :: Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor)))
_linalg_solve_ex_tt Ptr Tensor
_A Ptr Tensor
_B =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_linalg_solve_ex(
    *$(at::Tensor* _A)
  , *$(at::Tensor* _B)));
  }|]

_linalg_solve_ex_out_ttttttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
_linalg_solve_ex_out_ttttttbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor)))
_linalg_solve_ex_out_ttttttbb Ptr Tensor
_result Ptr Tensor
_LU Ptr Tensor
_pivots Ptr Tensor
_info Ptr Tensor
_A Ptr Tensor
_B CBool
_left CBool
_check_errors =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_linalg_solve_ex_out(
    *$(at::Tensor* _result)
  , *$(at::Tensor* _LU)
  , *$(at::Tensor* _pivots)
  , *$(at::Tensor* _info)
  , *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)
  , $(bool _check_errors)));
  }|]

_linalg_solve_ex_out_ttttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
_linalg_solve_ex_out_ttttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor)))
_linalg_solve_ex_out_ttttttb Ptr Tensor
_result Ptr Tensor
_LU Ptr Tensor
_pivots Ptr Tensor
_info Ptr Tensor
_A Ptr Tensor
_B CBool
_left =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_linalg_solve_ex_out(
    *$(at::Tensor* _result)
  , *$(at::Tensor* _LU)
  , *$(at::Tensor* _pivots)
  , *$(at::Tensor* _info)
  , *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)));
  }|]

_linalg_solve_ex_out_tttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
_linalg_solve_ex_out_tttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor)))
_linalg_solve_ex_out_tttttt Ptr Tensor
_result Ptr Tensor
_LU Ptr Tensor
_pivots Ptr Tensor
_info Ptr Tensor
_A Ptr Tensor
_B =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_linalg_solve_ex_out(
    *$(at::Tensor* _result)
  , *$(at::Tensor* _LU)
  , *$(at::Tensor* _pivots)
  , *$(at::Tensor* _info)
  , *$(at::Tensor* _A)
  , *$(at::Tensor* _B)));
  }|]

linalg_solve_ex_ttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_solve_ex_ttbb :: Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_solve_ex_ttbb Ptr Tensor
_A Ptr Tensor
_B CBool
_left CBool
_check_errors =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex(
    *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)
  , $(bool _check_errors)));
  }|]

linalg_solve_ex_ttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_solve_ex_ttb :: Ptr Tensor
-> Ptr Tensor -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_solve_ex_ttb Ptr Tensor
_A Ptr Tensor
_B CBool
_left =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex(
    *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)));
  }|]

linalg_solve_ex_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_solve_ex_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_solve_ex_tt Ptr Tensor
_A Ptr Tensor
_B =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex(
    *$(at::Tensor* _A)
  , *$(at::Tensor* _B)));
  }|]

linalg_solve_ex_out_ttttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_solve_ex_out_ttttbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_solve_ex_out_ttttbb Ptr Tensor
_result Ptr Tensor
_info Ptr Tensor
_A Ptr Tensor
_B CBool
_left CBool
_check_errors =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex_out(
    *$(at::Tensor* _result)
  , *$(at::Tensor* _info)
  , *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)
  , $(bool _check_errors)));
  }|]

linalg_solve_ex_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_solve_ex_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_solve_ex_out_ttttb Ptr Tensor
_result Ptr Tensor
_info Ptr Tensor
_A Ptr Tensor
_B CBool
_left =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex_out(
    *$(at::Tensor* _result)
  , *$(at::Tensor* _info)
  , *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)));
  }|]

linalg_solve_ex_out_tttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_solve_ex_out_tttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_solve_ex_out_tttt Ptr Tensor
_result Ptr Tensor
_info Ptr Tensor
_A Ptr Tensor
_B =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_solve_ex_out(
    *$(at::Tensor* _result)
  , *$(at::Tensor* _info)
  , *$(at::Tensor* _A)
  , *$(at::Tensor* _B)));
  }|]

linalg_solve_ttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_solve_ttb :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
linalg_solve_ttb Ptr Tensor
_A Ptr Tensor
_B CBool
_left =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve(
    *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)));
  }|]

linalg_solve_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_solve_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_solve_tt Ptr Tensor
_A Ptr Tensor
_B =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve(
    *$(at::Tensor* _A)
  , *$(at::Tensor* _B)));
  }|]

linalg_solve_out_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_solve_out_tttb :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
linalg_solve_out_tttb Ptr Tensor
_out Ptr Tensor
_A Ptr Tensor
_B CBool
_left =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _A)
  , *$(at::Tensor* _B)
  , $(bool _left)));
  }|]

linalg_solve_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_solve_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_solve_out_ttt Ptr Tensor
_out Ptr Tensor
_A Ptr Tensor
_B =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_solve_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _A)
  , *$(at::Tensor* _B)));
  }|]

linalg_tensorinv_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
linalg_tensorinv_tl :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
linalg_tensorinv_tl Ptr Tensor
_self Int64
_ind =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorinv(
    *$(at::Tensor* _self)
  , $(int64_t _ind)));
  }|]

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

linalg_tensorinv_out_ttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
linalg_tensorinv_out_ttl :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
linalg_tensorinv_out_ttl Ptr Tensor
_out Ptr Tensor
_self Int64
_ind =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorinv_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _ind)));
  }|]

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

linalg_tensorsolve_ttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
linalg_tensorsolve_ttl :: Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
linalg_tensorsolve_ttl Ptr Tensor
_self Ptr Tensor
_other Ptr IntArray
_dims =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorsolve(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _other)
  , *$(std::vector<int64_t>* _dims)));
  }|]

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

linalg_tensorsolve_out_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
linalg_tensorsolve_out_tttl :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
linalg_tensorsolve_out_tttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_other Ptr IntArray
_dims =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_tensorsolve_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _other)
  , *$(std::vector<int64_t>* _dims)));
  }|]

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

linalg_qr_ts
  :: Ptr Tensor
  -> Ptr StdString
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_qr_ts :: Ptr Tensor
-> Ptr StdString -> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_qr_ts Ptr Tensor
_A Ptr StdString
_mode =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_qr(
    *$(at::Tensor* _A)
  , *$(std::string* _mode)));
  }|]

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

linalg_qr_out_ttts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr StdString
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_qr_out_ttts :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr StdString
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_qr_out_ttts Ptr Tensor
_Q Ptr Tensor
_R Ptr Tensor
_A Ptr StdString
_mode =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_qr_out(
    *$(at::Tensor* _Q)
  , *$(at::Tensor* _R)
  , *$(at::Tensor* _A)
  , *$(std::string* _mode)));
  }|]

linalg_qr_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
linalg_qr_out_ttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
linalg_qr_out_ttt Ptr Tensor
_Q Ptr Tensor
_R Ptr Tensor
_A =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::linalg_qr_out(
    *$(at::Tensor* _Q)
  , *$(at::Tensor* _R)
  , *$(at::Tensor* _A)));
  }|]

linalg_matrix_power_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
linalg_matrix_power_tl :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
linalg_matrix_power_tl Ptr Tensor
_self Int64
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_power(
    *$(at::Tensor* _self)
  , $(int64_t _n)));
  }|]

linalg_matrix_power_out_ttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
linalg_matrix_power_out_ttl :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
linalg_matrix_power_out_ttl Ptr Tensor
_out Ptr Tensor
_self Int64
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_power_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _n)));
  }|]

linalg_matrix_rank_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_matrix_rank_tttb :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
linalg_matrix_rank_tttb Ptr Tensor
_input Ptr Tensor
_atol Ptr Tensor
_rtol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _input)
  , *$(at::Tensor* _atol)
  , *$(at::Tensor* _rtol)
  , $(bool _hermitian)));
  }|]

linalg_matrix_rank_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_matrix_rank_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_matrix_rank_ttt Ptr Tensor
_input Ptr Tensor
_atol Ptr Tensor
_rtol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _input)
  , *$(at::Tensor* _atol)
  , *$(at::Tensor* _rtol)));
  }|]

linalg_matrix_rank_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_matrix_rank_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_matrix_rank_tt Ptr Tensor
_input Ptr Tensor
_atol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _input)
  , *$(at::Tensor* _atol)));
  }|]

linalg_matrix_rank_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
linalg_matrix_rank_t :: Ptr Tensor -> IO (Ptr Tensor)
linalg_matrix_rank_t Ptr Tensor
_input =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _input)));
  }|]

linalg_matrix_rank_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr Tensor)
linalg_matrix_rank_out_ttttb Ptr Tensor
_out Ptr Tensor
_input Ptr Tensor
_atol Ptr Tensor
_rtol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _atol)
  , *$(at::Tensor* _rtol)
  , $(bool _hermitian)));
  }|]

linalg_matrix_rank_out_tttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_tttt :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_matrix_rank_out_tttt Ptr Tensor
_out Ptr Tensor
_input Ptr Tensor
_atol Ptr Tensor
_rtol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _atol)
  , *$(at::Tensor* _rtol)));
  }|]

linalg_matrix_rank_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttt Ptr Tensor
_out Ptr Tensor
_input Ptr Tensor
_atol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _atol)));
  }|]

linalg_matrix_rank_out_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
linalg_matrix_rank_out_tt Ptr Tensor
_out Ptr Tensor
_input =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _input)));
  }|]

linalg_matrix_rank_tddb
  :: Ptr Tensor
  -> CDouble
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
linalg_matrix_rank_tddb :: Ptr Tensor -> CDouble -> CDouble -> CBool -> IO (Ptr Tensor)
linalg_matrix_rank_tddb Ptr Tensor
_self CDouble
_atol CDouble
_rtol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _self)
  , $(double _atol)
  , $(double _rtol)
  , $(bool _hermitian)));
  }|]

linalg_matrix_rank_tdd
  :: Ptr Tensor
  -> CDouble
  -> CDouble
  -> IO (Ptr Tensor)
linalg_matrix_rank_tdd :: Ptr Tensor -> CDouble -> CDouble -> IO (Ptr Tensor)
linalg_matrix_rank_tdd Ptr Tensor
_self CDouble
_atol CDouble
_rtol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _self)
  , $(double _atol)
  , $(double _rtol)));
  }|]

linalg_matrix_rank_td
  :: Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
linalg_matrix_rank_td :: Ptr Tensor -> CDouble -> IO (Ptr Tensor)
linalg_matrix_rank_td Ptr Tensor
_self CDouble
_atol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _self)
  , $(double _atol)));
  }|]

linalg_matrix_rank_out_ttddb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttddb :: Ptr Tensor
-> Ptr Tensor -> CDouble -> CDouble -> CBool -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttddb Ptr Tensor
_out Ptr Tensor
_self CDouble
_atol CDouble
_rtol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _atol)
  , $(double _rtol)
  , $(bool _hermitian)));
  }|]

linalg_matrix_rank_out_ttdd
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CDouble
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttdd :: Ptr Tensor -> Ptr Tensor -> CDouble -> CDouble -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttdd Ptr Tensor
_out Ptr Tensor
_self CDouble
_atol CDouble
_rtol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _atol)
  , $(double _rtol)));
  }|]

linalg_matrix_rank_out_ttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttd :: Ptr Tensor -> Ptr Tensor -> CDouble -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttd Ptr Tensor
_out Ptr Tensor
_self CDouble
_atol =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _atol)));
  }|]

linalg_matrix_rank_tdb
  :: Ptr Tensor
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
linalg_matrix_rank_tdb :: Ptr Tensor -> CDouble -> CBool -> IO (Ptr Tensor)
linalg_matrix_rank_tdb Ptr Tensor
_self CDouble
_tol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _self)
  , $(double _tol)
  , $(bool _hermitian)));
  }|]

linalg_matrix_rank_out_ttdb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttdb :: Ptr Tensor -> Ptr Tensor -> CDouble -> CBool -> IO (Ptr Tensor)
linalg_matrix_rank_out_ttdb Ptr Tensor
_out Ptr Tensor
_self CDouble
_tol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _tol)
  , $(bool _hermitian)));
  }|]

linalg_matrix_rank_ttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_matrix_rank_ttb :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
linalg_matrix_rank_ttb Ptr Tensor
_input Ptr Tensor
_tol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank(
    *$(at::Tensor* _input)
  , *$(at::Tensor* _tol)
  , $(bool _hermitian)));
  }|]

linalg_matrix_rank_out_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
linalg_matrix_rank_out_tttb :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
linalg_matrix_rank_out_tttb Ptr Tensor
_out Ptr Tensor
_input Ptr Tensor
_tol CBool
_hermitian =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::linalg_matrix_rank_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _tol)
  , $(bool _hermitian)));
  }|]

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

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

nested_to_padded_tensor_tdl
  :: Ptr Tensor
  -> CDouble
  -> Ptr IntArray
  -> IO (Ptr Tensor)
nested_to_padded_tensor_tdl :: Ptr Tensor -> CDouble -> Ptr IntArray -> IO (Ptr Tensor)
nested_to_padded_tensor_tdl Ptr Tensor
_self CDouble
_padding Ptr IntArray
_output_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nested_to_padded_tensor(
    *$(at::Tensor* _self)
  , $(double _padding)
  , *$(std::vector<int64_t>* _output_size)));
  }|]

nested_to_padded_tensor_td
  :: Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
nested_to_padded_tensor_td :: Ptr Tensor -> CDouble -> IO (Ptr Tensor)
nested_to_padded_tensor_td Ptr Tensor
_self CDouble
_padding =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nested_to_padded_tensor(
    *$(at::Tensor* _self)
  , $(double _padding)));
  }|]

_test_serialization_subcmul_tts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
_test_serialization_subcmul_tts :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
_test_serialization_subcmul_tts Ptr Tensor
_self Ptr Tensor
_other Ptr Scalar
_alpha =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_serialization_subcmul(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _other)
  , *$(at::Scalar* _alpha)));
  }|]

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

_test_optional_intlist_tl
  :: Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_test_optional_intlist_tl :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_test_optional_intlist_tl Ptr Tensor
_values Ptr IntArray
_addends =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_intlist(
    *$(at::Tensor* _values)
  , *$(std::vector<int64_t>* _addends)));
  }|]

_test_optional_filled_intlist_tl
  :: Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_test_optional_filled_intlist_tl :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_test_optional_filled_intlist_tl Ptr Tensor
_values Ptr IntArray
_addends =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_filled_intlist(
    *$(at::Tensor* _values)
  , *$(std::vector<int64_t>* _addends)));
  }|]

_test_optional_floatlist_ta
  :: Ptr Tensor
  -> Ptr (StdVector CDouble)
  -> IO (Ptr Tensor)
_test_optional_floatlist_ta :: Ptr Tensor -> Ptr (StdVector CDouble) -> IO (Ptr Tensor)
_test_optional_floatlist_ta Ptr Tensor
_values Ptr (StdVector CDouble)
_addends =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_optional_floatlist(
    *$(at::Tensor* _values)
  , *$(std::vector<double>* _addends)));
  }|]

_test_string_default_tss
  :: Ptr Tensor
  -> Ptr StdString
  -> Ptr StdString
  -> IO (Ptr Tensor)
_test_string_default_tss :: Ptr Tensor -> Ptr StdString -> Ptr StdString -> IO (Ptr Tensor)
_test_string_default_tss Ptr Tensor
_dummy Ptr StdString
_a Ptr StdString
_b =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_string_default(
    *$(at::Tensor* _dummy)
  , *$(std::string* _a)
  , *$(std::string* _b)));
  }|]

_test_string_default_ts
  :: Ptr Tensor
  -> Ptr StdString
  -> IO (Ptr Tensor)
_test_string_default_ts :: Ptr Tensor -> Ptr StdString -> IO (Ptr Tensor)
_test_string_default_ts Ptr Tensor
_dummy Ptr StdString
_a =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_string_default(
    *$(at::Tensor* _dummy)
  , *$(std::string* _a)));
  }|]

_test_string_default_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
_test_string_default_t :: Ptr Tensor -> IO (Ptr Tensor)
_test_string_default_t Ptr Tensor
_dummy =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_string_default(
    *$(at::Tensor* _dummy)));
  }|]

_test_ambiguous_defaults_tll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
_test_ambiguous_defaults_tll :: Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
_test_ambiguous_defaults_tll Ptr Tensor
_dummy Int64
_a Int64
_b =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_ambiguous_defaults(
    *$(at::Tensor* _dummy)
  , $(int64_t _a)
  , $(int64_t _b)));
  }|]

_test_ambiguous_defaults_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
_test_ambiguous_defaults_tl :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
_test_ambiguous_defaults_tl Ptr Tensor
_dummy Int64
_a =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_ambiguous_defaults(
    *$(at::Tensor* _dummy)
  , $(int64_t _a)));
  }|]

_test_ambiguous_defaults_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
_test_ambiguous_defaults_t :: Ptr Tensor -> IO (Ptr Tensor)
_test_ambiguous_defaults_t Ptr Tensor
_dummy =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_ambiguous_defaults(
    *$(at::Tensor* _dummy)));
  }|]

_test_ambiguous_defaults_tls
  :: Ptr Tensor
  -> Int64
  -> Ptr StdString
  -> IO (Ptr Tensor)
_test_ambiguous_defaults_tls :: Ptr Tensor -> Int64 -> Ptr StdString -> IO (Ptr Tensor)
_test_ambiguous_defaults_tls Ptr Tensor
_dummy Int64
_a Ptr StdString
_b =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_ambiguous_defaults(
    *$(at::Tensor* _dummy)
  , $(int64_t _a)
  , *$(std::string* _b)));
  }|]

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

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

_test_autograd_multiple_dispatch_tb
  :: Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
_test_autograd_multiple_dispatch_tb :: Ptr Tensor -> CBool -> IO (Ptr Tensor)
_test_autograd_multiple_dispatch_tb Ptr Tensor
_self CBool
_b =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_test_autograd_multiple_dispatch(
    *$(at::Tensor* _self)
  , $(bool _b)));
  }|]

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

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

segment_reduce_tstttlbs
  :: Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> Ptr Scalar
  -> IO (Ptr Tensor)
segment_reduce_tstttlbs :: Ptr Tensor
-> Ptr StdString
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> Ptr Scalar
-> IO (Ptr Tensor)
segment_reduce_tstttlbs Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths Ptr Tensor
_indices Ptr Tensor
_offsets Int64
_axis CBool
_unsafe Ptr Scalar
_initial =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
    *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _offsets)
  , $(int64_t _axis)
  , $(bool _unsafe)
  , *$(at::Scalar* _initial)));
  }|]

segment_reduce_tstttlb
  :: Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
segment_reduce_tstttlb :: Ptr Tensor
-> Ptr StdString
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> IO (Ptr Tensor)
segment_reduce_tstttlb Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths Ptr Tensor
_indices Ptr Tensor
_offsets Int64
_axis CBool
_unsafe =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
    *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _offsets)
  , $(int64_t _axis)
  , $(bool _unsafe)));
  }|]

segment_reduce_tstttl
  :: Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
segment_reduce_tstttl :: Ptr Tensor
-> Ptr StdString
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
segment_reduce_tstttl Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths Ptr Tensor
_indices Ptr Tensor
_offsets Int64
_axis =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
    *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _offsets)
  , $(int64_t _axis)));
  }|]

segment_reduce_tsttt
  :: Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
segment_reduce_tsttt :: Ptr Tensor
-> Ptr StdString
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr Tensor)
segment_reduce_tsttt Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths Ptr Tensor
_indices Ptr Tensor
_offsets =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
    *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _offsets)));
  }|]

segment_reduce_tstt
  :: Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
segment_reduce_tstt :: Ptr Tensor
-> Ptr StdString -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
segment_reduce_tstt Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths Ptr Tensor
_indices =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
    *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)
  , *$(at::Tensor* _indices)));
  }|]

segment_reduce_tst
  :: Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> IO (Ptr Tensor)
segment_reduce_tst :: Ptr Tensor -> Ptr StdString -> Ptr Tensor -> IO (Ptr Tensor)
segment_reduce_tst Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
    *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)));
  }|]

segment_reduce_ts
  :: Ptr Tensor
  -> Ptr StdString
  -> IO (Ptr Tensor)
segment_reduce_ts :: Ptr Tensor -> Ptr StdString -> IO (Ptr Tensor)
segment_reduce_ts Ptr Tensor
_data Ptr StdString
_reduce =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::segment_reduce(
    *$(at::Tensor* _data)
  , *$(std::string* _reduce)));
  }|]

_segment_reduce_backward_tttsttls
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Ptr Scalar
  -> IO (Ptr Tensor)
_segment_reduce_backward_tttsttls :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr StdString
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Ptr Scalar
-> IO (Ptr Tensor)
_segment_reduce_backward_tttsttls Ptr Tensor
_grad Ptr Tensor
_output Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths Ptr Tensor
_offsets Int64
_axis Ptr Scalar
_initial =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
    *$(at::Tensor* _grad)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)
  , *$(at::Tensor* _offsets)
  , $(int64_t _axis)
  , *$(at::Scalar* _initial)));
  }|]

_segment_reduce_backward_tttsttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
_segment_reduce_backward_tttsttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr StdString
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
_segment_reduce_backward_tttsttl Ptr Tensor
_grad Ptr Tensor
_output Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths Ptr Tensor
_offsets Int64
_axis =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
    *$(at::Tensor* _grad)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)
  , *$(at::Tensor* _offsets)
  , $(int64_t _axis)));
  }|]

_segment_reduce_backward_tttstt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_segment_reduce_backward_tttstt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr StdString
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr Tensor)
_segment_reduce_backward_tttstt Ptr Tensor
_grad Ptr Tensor
_output Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths Ptr Tensor
_offsets =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
    *$(at::Tensor* _grad)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)
  , *$(at::Tensor* _offsets)));
  }|]

_segment_reduce_backward_tttst
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr StdString
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_segment_reduce_backward_tttst :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr StdString
-> Ptr Tensor
-> IO (Ptr Tensor)
_segment_reduce_backward_tttst Ptr Tensor
_grad Ptr Tensor
_output Ptr Tensor
_data Ptr StdString
_reduce Ptr Tensor
_lengths =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
    *$(at::Tensor* _grad)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _data)
  , *$(std::string* _reduce)
  , *$(at::Tensor* _lengths)));
  }|]

_segment_reduce_backward_ttts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr StdString
  -> IO (Ptr Tensor)
_segment_reduce_backward_ttts :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr StdString -> IO (Ptr Tensor)
_segment_reduce_backward_ttts Ptr Tensor
_grad Ptr Tensor
_output Ptr Tensor
_data Ptr StdString
_reduce =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_segment_reduce_backward(
    *$(at::Tensor* _grad)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _data)
  , *$(std::string* _reduce)));
  }|]

pad_sequence_lbd
  :: Ptr TensorList
  -> CBool
  -> CDouble
  -> IO (Ptr Tensor)
pad_sequence_lbd :: Ptr TensorList -> CBool -> CDouble -> IO (Ptr Tensor)
pad_sequence_lbd Ptr TensorList
_sequences CBool
_batch_first CDouble
_padding_value =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pad_sequence(
    *$(std::vector<at::Tensor>* _sequences)
  , $(bool _batch_first)
  , $(double _padding_value)));
  }|]

pad_sequence_lb
  :: Ptr TensorList
  -> CBool
  -> IO (Ptr Tensor)
pad_sequence_lb :: Ptr TensorList -> CBool -> IO (Ptr Tensor)
pad_sequence_lb Ptr TensorList
_sequences CBool
_batch_first =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::pad_sequence(
    *$(std::vector<at::Tensor>* _sequences)
  , $(bool _batch_first)));
  }|]

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

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

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

_nested_tensor_from_tensor_list_lsLDb
  :: Ptr TensorList
  -> ScalarType
  -> Layout
  -> DeviceType
  -> CBool
  -> IO (Ptr Tensor)
_nested_tensor_from_tensor_list_lsLDb :: Ptr TensorList
-> ScalarType
-> ScalarType
-> DeviceType
-> CBool
-> IO (Ptr Tensor)
_nested_tensor_from_tensor_list_lsLDb Ptr TensorList
_list ScalarType
_dtype ScalarType
_layout DeviceType
_device CBool
_pin_memory =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
    *$(std::vector<at::Tensor>* _list)
  , $(at::ScalarType _dtype)
  , $(at::Layout _layout)
  , $(at::DeviceType _device)
  , $(bool _pin_memory)));
  }|]

_nested_tensor_from_tensor_list_lsLD
  :: Ptr TensorList
  -> ScalarType
  -> Layout
  -> DeviceType
  -> IO (Ptr Tensor)
_nested_tensor_from_tensor_list_lsLD :: Ptr TensorList
-> ScalarType -> ScalarType -> DeviceType -> IO (Ptr Tensor)
_nested_tensor_from_tensor_list_lsLD Ptr TensorList
_list ScalarType
_dtype ScalarType
_layout DeviceType
_device =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
    *$(std::vector<at::Tensor>* _list)
  , $(at::ScalarType _dtype)
  , $(at::Layout _layout)
  , $(at::DeviceType _device)));
  }|]

_nested_tensor_from_tensor_list_lsL
  :: Ptr TensorList
  -> ScalarType
  -> Layout
  -> IO (Ptr Tensor)
_nested_tensor_from_tensor_list_lsL :: Ptr TensorList -> ScalarType -> ScalarType -> IO (Ptr Tensor)
_nested_tensor_from_tensor_list_lsL Ptr TensorList
_list ScalarType
_dtype ScalarType
_layout =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
    *$(std::vector<at::Tensor>* _list)
  , $(at::ScalarType _dtype)
  , $(at::Layout _layout)));
  }|]

_nested_tensor_from_tensor_list_ls
  :: Ptr TensorList
  -> ScalarType
  -> IO (Ptr Tensor)
_nested_tensor_from_tensor_list_ls :: Ptr TensorList -> ScalarType -> IO (Ptr Tensor)
_nested_tensor_from_tensor_list_ls Ptr TensorList
_list ScalarType
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_tensor_list(
    *$(std::vector<at::Tensor>* _list)
  , $(at::ScalarType _dtype)));
  }|]

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

_fw_primal_copy_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
_fw_primal_copy_tl :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
_fw_primal_copy_tl Ptr Tensor
_self Int64
_level =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fw_primal_copy(
    *$(at::Tensor* _self)
  , $(int64_t _level)));
  }|]

_make_dual_copy_ttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
_make_dual_copy_ttl :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
_make_dual_copy_ttl Ptr Tensor
_primal Ptr Tensor
_tangent Int64
_level =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_dual_copy(
    *$(at::Tensor* _primal)
  , *$(at::Tensor* _tangent)
  , $(int64_t _level)));
  }|]

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

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

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

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

as_strided_copy_tlll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> IO (Ptr Tensor)
as_strided_copy_tlll :: Ptr Tensor
-> Ptr IntArray -> Ptr IntArray -> Int64 -> IO (Ptr Tensor)
as_strided_copy_tlll Ptr Tensor
_self Ptr IntArray
_size Ptr IntArray
_stride Int64
_storage_offset =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)
  , *$(std::vector<int64_t>* _stride)
  , $(int64_t _storage_offset)));
  }|]

as_strided_copy_tll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
as_strided_copy_tll :: Ptr Tensor -> Ptr IntArray -> Ptr IntArray -> IO (Ptr Tensor)
as_strided_copy_tll Ptr Tensor
_self Ptr IntArray
_size Ptr IntArray
_stride =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::as_strided_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)
  , *$(std::vector<int64_t>* _stride)));
  }|]

_sparse_broadcast_to_copy_tl
  :: Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_sparse_broadcast_to_copy_tl :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_sparse_broadcast_to_copy_tl Ptr Tensor
_self Ptr IntArray
_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_broadcast_to_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)));
  }|]

diagonal_copy_tlll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
diagonal_copy_tlll :: Ptr Tensor -> Int64 -> Int64 -> Int64 -> IO (Ptr Tensor)
diagonal_copy_tlll Ptr Tensor
_self Int64
_offset Int64
_dim1 Int64
_dim2 =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy(
    *$(at::Tensor* _self)
  , $(int64_t _offset)
  , $(int64_t _dim1)
  , $(int64_t _dim2)));
  }|]

diagonal_copy_tll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
diagonal_copy_tll :: Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
diagonal_copy_tll Ptr Tensor
_self Int64
_offset Int64
_dim1 =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy(
    *$(at::Tensor* _self)
  , $(int64_t _offset)
  , $(int64_t _dim1)));
  }|]

diagonal_copy_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
diagonal_copy_tl :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
diagonal_copy_tl Ptr Tensor
_self Int64
_offset =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::diagonal_copy(
    *$(at::Tensor* _self)
  , $(int64_t _offset)));
  }|]

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

expand_copy_tlb
  :: Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
expand_copy_tlb :: Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
expand_copy_tlb Ptr Tensor
_self Ptr IntArray
_size CBool
_implicit =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expand_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)
  , $(bool _implicit)));
  }|]

expand_copy_tl
  :: Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
expand_copy_tl :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
expand_copy_tl Ptr Tensor
_self Ptr IntArray
_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::expand_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)));
  }|]

permute_copy_tl
  :: Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
permute_copy_tl :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
permute_copy_tl Ptr Tensor
_self Ptr IntArray
_dims =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::permute_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dims)));
  }|]

_reshape_alias_copy_tll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_reshape_alias_copy_tll :: Ptr Tensor -> Ptr IntArray -> Ptr IntArray -> IO (Ptr Tensor)
_reshape_alias_copy_tll Ptr Tensor
_self Ptr IntArray
_size Ptr IntArray
_stride =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_reshape_alias_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)
  , *$(std::vector<int64_t>* _stride)));
  }|]

select_copy_tll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
select_copy_tll :: Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
select_copy_tll Ptr Tensor
_self Int64
_dim Int64
_index =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(int64_t _index)));
  }|]

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

slice_copy_tllll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
slice_copy_tllll :: Ptr Tensor -> Int64 -> Int64 -> Int64 -> Int64 -> IO (Ptr Tensor)
slice_copy_tllll Ptr Tensor
_self Int64
_dim Int64
_start Int64
_end Int64
_step =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(int64_t _start)
  , $(int64_t _end)
  , $(int64_t _step)));
  }|]

slice_copy_tlll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
slice_copy_tlll :: Ptr Tensor -> Int64 -> Int64 -> Int64 -> IO (Ptr Tensor)
slice_copy_tlll Ptr Tensor
_self Int64
_dim Int64
_start Int64
_end =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(int64_t _start)
  , $(int64_t _end)));
  }|]

slice_copy_tll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
slice_copy_tll :: Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
slice_copy_tll Ptr Tensor
_self Int64
_dim Int64
_start =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(int64_t _start)));
  }|]

slice_copy_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
slice_copy_tl :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
slice_copy_tl Ptr Tensor
_self Int64
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

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

split_copy_tll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr TensorList)
split_copy_tll :: Ptr Tensor -> Int64 -> Int64 -> IO (Ptr TensorList)
split_copy_tll Ptr Tensor
_self Int64
_split_size Int64
_dim =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_copy(
    *$(at::Tensor* _self)
  , $(int64_t _split_size)
  , $(int64_t _dim)));
  }|]

split_copy_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr TensorList)
split_copy_tl :: Ptr Tensor -> Int64 -> IO (Ptr TensorList)
split_copy_tl Ptr Tensor
_self Int64
_split_size =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_copy(
    *$(at::Tensor* _self)
  , $(int64_t _split_size)));
  }|]

split_with_sizes_copy_tll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> IO (Ptr TensorList)
split_with_sizes_copy_tll :: Ptr Tensor -> Ptr IntArray -> Int64 -> IO (Ptr TensorList)
split_with_sizes_copy_tll Ptr Tensor
_self Ptr IntArray
_split_sizes Int64
_dim =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_with_sizes_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _split_sizes)
  , $(int64_t _dim)));
  }|]

split_with_sizes_copy_tl
  :: Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr TensorList)
split_with_sizes_copy_tl :: Ptr Tensor -> Ptr IntArray -> IO (Ptr TensorList)
split_with_sizes_copy_tl Ptr Tensor
_self Ptr IntArray
_split_sizes =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::split_with_sizes_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _split_sizes)));
  }|]

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

squeeze_copy_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
squeeze_copy_tl :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
squeeze_copy_tl Ptr Tensor
_self Int64
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::squeeze_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

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

transpose_copy_tll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
transpose_copy_tll :: Ptr Tensor -> Int64 -> Int64 -> IO (Ptr Tensor)
transpose_copy_tll Ptr Tensor
_self Int64
_dim0 Int64
_dim1 =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::transpose_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim0)
  , $(int64_t _dim1)));
  }|]

unsqueeze_copy_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
unsqueeze_copy_tl :: Ptr Tensor -> Int64 -> IO (Ptr Tensor)
unsqueeze_copy_tl Ptr Tensor
_self Int64
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unsqueeze_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

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

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

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

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

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

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

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

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

unbind_copy_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr TensorList)
unbind_copy_tl :: Ptr Tensor -> Int64 -> IO (Ptr TensorList)
unbind_copy_tl Ptr Tensor
_self Int64
_dim =
  [C.throwBlock| std::vector<at::Tensor>* { return new std::vector<at::Tensor>(at::unbind_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

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

unbind_copy_out_ltl
  :: Ptr TensorList
  -> Ptr Tensor
  -> Int64
  -> IO (())
unbind_copy_out_ltl :: Ptr TensorList -> Ptr Tensor -> Int64 -> IO ()
unbind_copy_out_ltl Ptr TensorList
_out Ptr Tensor
_self Int64
_dim =
  [C.throwBlock| void {  (at::unbind_copy_out(
    *$(std::vector<at::Tensor>* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

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

split_copy_out_ltll
  :: Ptr TensorList
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> IO (())
split_copy_out_ltll :: Ptr TensorList -> Ptr Tensor -> Int64 -> Int64 -> IO ()
split_copy_out_ltll Ptr TensorList
_out Ptr Tensor
_self Int64
_split_size Int64
_dim =
  [C.throwBlock| void {  (at::split_copy_out(
    *$(std::vector<at::Tensor>* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _split_size)
  , $(int64_t _dim)));
  }|]

split_copy_out_ltl
  :: Ptr TensorList
  -> Ptr Tensor
  -> Int64
  -> IO (())
split_copy_out_ltl :: Ptr TensorList -> Ptr Tensor -> Int64 -> IO ()
split_copy_out_ltl Ptr TensorList
_out Ptr Tensor
_self Int64
_split_size =
  [C.throwBlock| void {  (at::split_copy_out(
    *$(std::vector<at::Tensor>* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _split_size)));
  }|]

split_with_sizes_copy_out_ltll
  :: Ptr TensorList
  -> Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> IO (())
split_with_sizes_copy_out_ltll :: Ptr TensorList -> Ptr Tensor -> Ptr IntArray -> Int64 -> IO ()
split_with_sizes_copy_out_ltll Ptr TensorList
_out Ptr Tensor
_self Ptr IntArray
_split_sizes Int64
_dim =
  [C.throwBlock| void {  (at::split_with_sizes_copy_out(
    *$(std::vector<at::Tensor>* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _split_sizes)
  , $(int64_t _dim)));
  }|]

split_with_sizes_copy_out_ltl
  :: Ptr TensorList
  -> Ptr Tensor
  -> Ptr IntArray
  -> IO (())
split_with_sizes_copy_out_ltl :: Ptr TensorList -> Ptr Tensor -> Ptr IntArray -> IO ()
split_with_sizes_copy_out_ltl Ptr TensorList
_out Ptr Tensor
_self Ptr IntArray
_split_sizes =
  [C.throwBlock| void {  (at::split_with_sizes_copy_out(
    *$(std::vector<at::Tensor>* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _split_sizes)));
  }|]

view_copy_tl
  :: Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
view_copy_tl :: Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
view_copy_tl Ptr Tensor
_self Ptr IntArray
_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_copy(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)));
  }|]

view_copy_ts
  :: Ptr Tensor
  -> ScalarType
  -> IO (Ptr Tensor)
view_copy_ts :: Ptr Tensor -> ScalarType -> IO (Ptr Tensor)
view_copy_ts Ptr Tensor
_self ScalarType
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::view_copy(
    *$(at::Tensor* _self)
  , $(at::ScalarType _dtype)));
  }|]

unfold_copy_tlll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
unfold_copy_tlll :: Ptr Tensor -> Int64 -> Int64 -> Int64 -> IO (Ptr Tensor)
unfold_copy_tlll Ptr Tensor
_self Int64
_dimension Int64
_size Int64
_step =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unfold_copy(
    *$(at::Tensor* _self)
  , $(int64_t _dimension)
  , $(int64_t _size)
  , $(int64_t _step)));
  }|]

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

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

_transformer_encoder_layer_fwd_tllttttbbdtttttttttl
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> CDouble
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
_transformer_encoder_layer_fwd_tllttttbbdtttttttttl :: Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> CDouble
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
_transformer_encoder_layer_fwd_tllttttbbdtttttttttl Ptr Tensor
_src Int64
_embed_dim Int64
_num_heads Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias CBool
_use_gelu CBool
_norm_first CDouble
_eps Ptr Tensor
_norm_weight_1 Ptr Tensor
_norm_bias_1 Ptr Tensor
_norm_weight_2 Ptr Tensor
_norm_bias_2 Ptr Tensor
_ffn_weight_1 Ptr Tensor
_ffn_bias_1 Ptr Tensor
_ffn_weight_2 Ptr Tensor
_ffn_bias_2 Ptr Tensor
_mask Int64
_mask_type =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd(
    *$(at::Tensor* _src)
  , $(int64_t _embed_dim)
  , $(int64_t _num_heads)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)
  , $(bool _use_gelu)
  , $(bool _norm_first)
  , $(double _eps)
  , *$(at::Tensor* _norm_weight_1)
  , *$(at::Tensor* _norm_bias_1)
  , *$(at::Tensor* _norm_weight_2)
  , *$(at::Tensor* _norm_bias_2)
  , *$(at::Tensor* _ffn_weight_1)
  , *$(at::Tensor* _ffn_bias_1)
  , *$(at::Tensor* _ffn_weight_2)
  , *$(at::Tensor* _ffn_bias_2)
  , *$(at::Tensor* _mask)
  , $(int64_t _mask_type)));
  }|]

_transformer_encoder_layer_fwd_tllttttbbdttttttttt
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> CDouble
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_transformer_encoder_layer_fwd_tllttttbbdttttttttt :: Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> CDouble
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr Tensor)
_transformer_encoder_layer_fwd_tllttttbbdttttttttt Ptr Tensor
_src Int64
_embed_dim Int64
_num_heads Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias CBool
_use_gelu CBool
_norm_first CDouble
_eps Ptr Tensor
_norm_weight_1 Ptr Tensor
_norm_bias_1 Ptr Tensor
_norm_weight_2 Ptr Tensor
_norm_bias_2 Ptr Tensor
_ffn_weight_1 Ptr Tensor
_ffn_bias_1 Ptr Tensor
_ffn_weight_2 Ptr Tensor
_ffn_bias_2 Ptr Tensor
_mask =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd(
    *$(at::Tensor* _src)
  , $(int64_t _embed_dim)
  , $(int64_t _num_heads)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)
  , $(bool _use_gelu)
  , $(bool _norm_first)
  , $(double _eps)
  , *$(at::Tensor* _norm_weight_1)
  , *$(at::Tensor* _norm_bias_1)
  , *$(at::Tensor* _norm_weight_2)
  , *$(at::Tensor* _norm_bias_2)
  , *$(at::Tensor* _ffn_weight_1)
  , *$(at::Tensor* _ffn_bias_1)
  , *$(at::Tensor* _ffn_weight_2)
  , *$(at::Tensor* _ffn_bias_2)
  , *$(at::Tensor* _mask)));
  }|]

_transformer_encoder_layer_fwd_tllttttbbdtttttttt
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> CDouble
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_transformer_encoder_layer_fwd_tllttttbbdtttttttt :: Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> CDouble
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr Tensor)
_transformer_encoder_layer_fwd_tllttttbbdtttttttt Ptr Tensor
_src Int64
_embed_dim Int64
_num_heads Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias CBool
_use_gelu CBool
_norm_first CDouble
_eps Ptr Tensor
_norm_weight_1 Ptr Tensor
_norm_bias_1 Ptr Tensor
_norm_weight_2 Ptr Tensor
_norm_bias_2 Ptr Tensor
_ffn_weight_1 Ptr Tensor
_ffn_bias_1 Ptr Tensor
_ffn_weight_2 Ptr Tensor
_ffn_bias_2 =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_transformer_encoder_layer_fwd(
    *$(at::Tensor* _src)
  , $(int64_t _embed_dim)
  , $(int64_t _num_heads)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)
  , $(bool _use_gelu)
  , $(bool _norm_first)
  , $(double _eps)
  , *$(at::Tensor* _norm_weight_1)
  , *$(at::Tensor* _norm_bias_1)
  , *$(at::Tensor* _norm_weight_2)
  , *$(at::Tensor* _norm_bias_2)
  , *$(at::Tensor* _ffn_weight_1)
  , *$(at::Tensor* _ffn_bias_1)
  , *$(at::Tensor* _ffn_weight_2)
  , *$(at::Tensor* _ffn_bias_2)));
  }|]

_native_multi_head_attention_tttlltttttbbl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_native_multi_head_attention_tttlltttttbbl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_native_multi_head_attention_tttlltttttbbl Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Int64
_embed_dim Int64
_num_head Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias Ptr Tensor
_mask CBool
_need_weights CBool
_average_attn_weights Int64
_mask_type =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , $(int64_t _embed_dim)
  , $(int64_t _num_head)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)
  , *$(at::Tensor* _mask)
  , $(bool _need_weights)
  , $(bool _average_attn_weights)
  , $(int64_t _mask_type)));
  }|]

_native_multi_head_attention_tttlltttttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_native_multi_head_attention_tttlltttttbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_native_multi_head_attention_tttlltttttbb Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Int64
_embed_dim Int64
_num_head Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias Ptr Tensor
_mask CBool
_need_weights CBool
_average_attn_weights =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , $(int64_t _embed_dim)
  , $(int64_t _num_head)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)
  , *$(at::Tensor* _mask)
  , $(bool _need_weights)
  , $(bool _average_attn_weights)));
  }|]

_native_multi_head_attention_tttlltttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_native_multi_head_attention_tttlltttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_native_multi_head_attention_tttlltttttb Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Int64
_embed_dim Int64
_num_head Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias Ptr Tensor
_mask CBool
_need_weights =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , $(int64_t _embed_dim)
  , $(int64_t _num_head)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)
  , *$(at::Tensor* _mask)
  , $(bool _need_weights)));
  }|]

_native_multi_head_attention_tttllttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_native_multi_head_attention_tttllttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_native_multi_head_attention_tttllttttt Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Int64
_embed_dim Int64
_num_head Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias Ptr Tensor
_mask =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , $(int64_t _embed_dim)
  , $(int64_t _num_head)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)
  , *$(at::Tensor* _mask)));
  }|]

_native_multi_head_attention_tttlltttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_native_multi_head_attention_tttlltttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_native_multi_head_attention_tttlltttt Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Int64
_embed_dim Int64
_num_head Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_native_multi_head_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , $(int64_t _embed_dim)
  , $(int64_t _num_head)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)));
  }|]

scaled_dot_product_attention_ttttdb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CBool
  -> IO (Ptr Tensor)
scaled_dot_product_attention_ttttdb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> CBool
-> IO (Ptr Tensor)
scaled_dot_product_attention_ttttdb Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Ptr Tensor
_attn_mask CDouble
_dropout_p CBool
_is_causal =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scaled_dot_product_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , *$(at::Tensor* _attn_mask)
  , $(double _dropout_p)
  , $(bool _is_causal)));
  }|]

scaled_dot_product_attention_ttttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
scaled_dot_product_attention_ttttd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> IO (Ptr Tensor)
scaled_dot_product_attention_ttttd Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Ptr Tensor
_attn_mask CDouble
_dropout_p =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scaled_dot_product_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , *$(at::Tensor* _attn_mask)
  , $(double _dropout_p)));
  }|]

scaled_dot_product_attention_tttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
scaled_dot_product_attention_tttt :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
scaled_dot_product_attention_tttt Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Ptr Tensor
_attn_mask =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scaled_dot_product_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , *$(at::Tensor* _attn_mask)));
  }|]

scaled_dot_product_attention_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
scaled_dot_product_attention_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
scaled_dot_product_attention_ttt Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scaled_dot_product_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)));
  }|]

_fused_sdp_choice_ttttdb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CBool
  -> IO (Int64)
_fused_sdp_choice_ttttdb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> CBool
-> IO Int64
_fused_sdp_choice_ttttdb Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Ptr Tensor
_attn_mask CDouble
_dropout_p CBool
_is_causal =
  [C.throwBlock| int64_t { return (at::_fused_sdp_choice(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , *$(at::Tensor* _attn_mask)
  , $(double _dropout_p)
  , $(bool _is_causal)));
  }|]

_fused_sdp_choice_ttttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Int64)
_fused_sdp_choice_ttttd :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CDouble -> IO Int64
_fused_sdp_choice_ttttd Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Ptr Tensor
_attn_mask CDouble
_dropout_p =
  [C.throwBlock| int64_t { return (at::_fused_sdp_choice(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , *$(at::Tensor* _attn_mask)
  , $(double _dropout_p)));
  }|]

_fused_sdp_choice_tttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Int64)
_fused_sdp_choice_tttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO Int64
_fused_sdp_choice_tttt Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Ptr Tensor
_attn_mask =
  [C.throwBlock| int64_t { return (at::_fused_sdp_choice(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , *$(at::Tensor* _attn_mask)));
  }|]

_fused_sdp_choice_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Int64)
_fused_sdp_choice_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO Int64
_fused_sdp_choice_ttt Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value =
  [C.throwBlock| int64_t { return (at::_fused_sdp_choice(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)));
  }|]

_triton_scaled_dot_attention_tttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
_triton_scaled_dot_attention_tttd :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> CDouble -> IO (Ptr Tensor)
_triton_scaled_dot_attention_tttd Ptr Tensor
_q Ptr Tensor
_k Ptr Tensor
_v CDouble
_dropout_p =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_scaled_dot_attention(
    *$(at::Tensor* _q)
  , *$(at::Tensor* _k)
  , *$(at::Tensor* _v)
  , $(double _dropout_p)));
  }|]

_triton_scaled_dot_attention_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_triton_scaled_dot_attention_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_triton_scaled_dot_attention_ttt Ptr Tensor
_q Ptr Tensor
_k Ptr Tensor
_v =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_scaled_dot_attention(
    *$(at::Tensor* _q)
  , *$(at::Tensor* _k)
  , *$(at::Tensor* _v)));
  }|]

_triton_multi_head_attention_tttllttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_triton_multi_head_attention_tttllttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr Tensor)
_triton_multi_head_attention_tttllttttt Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Int64
_embed_dim Int64
_num_head Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias Ptr Tensor
_mask =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_multi_head_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , $(int64_t _embed_dim)
  , $(int64_t _num_head)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)
  , *$(at::Tensor* _mask)));
  }|]

_triton_multi_head_attention_tttlltttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_triton_multi_head_attention_tttlltttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr Tensor)
_triton_multi_head_attention_tttlltttt Ptr Tensor
_query Ptr Tensor
_key Ptr Tensor
_value Int64
_embed_dim Int64
_num_head Ptr Tensor
_qkv_weight Ptr Tensor
_qkv_bias Ptr Tensor
_proj_weight Ptr Tensor
_proj_bias =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_triton_multi_head_attention(
    *$(at::Tensor* _query)
  , *$(at::Tensor* _key)
  , *$(at::Tensor* _value)
  , $(int64_t _embed_dim)
  , $(int64_t _num_head)
  , *$(at::Tensor* _qkv_weight)
  , *$(at::Tensor* _qkv_bias)
  , *$(at::Tensor* _proj_weight)
  , *$(at::Tensor* _proj_bias)));
  }|]

special_airy_ai_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
special_airy_ai_t :: Ptr Tensor -> IO (Ptr Tensor)
special_airy_ai_t Ptr Tensor
_x =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_airy_ai(
    *$(at::Tensor* _x)));
  }|]

special_airy_ai_out_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_airy_ai_out_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_airy_ai_out_tt Ptr Tensor
_out Ptr Tensor
_x =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_airy_ai_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)));
  }|]

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

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

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

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

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

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

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

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

special_chebyshev_polynomial_t_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_tt Ptr Tensor
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t(
    *$(at::Tensor* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_t_st
  :: Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_st :: Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_st Ptr Scalar
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t(
    *$(at::Scalar* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_t_ts
  :: Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_ts :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_ts Ptr Tensor
_x Ptr Scalar
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t(
    *$(at::Tensor* _x)
  , *$(at::Scalar* _n)));
  }|]

special_chebyshev_polynomial_t_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_out_ttt Ptr Tensor
_out Ptr Tensor
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_t_out_tst
  :: Ptr Tensor
  -> Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_out_tst :: Ptr Tensor -> Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_out_tst Ptr Tensor
_out Ptr Scalar
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t_out(
    *$(at::Tensor* _out)
  , *$(at::Scalar* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_t_out_tts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_out_tts :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
special_chebyshev_polynomial_t_out_tts Ptr Tensor
_out Ptr Tensor
_x Ptr Scalar
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_t_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)
  , *$(at::Scalar* _n)));
  }|]

special_chebyshev_polynomial_u_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_tt Ptr Tensor
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u(
    *$(at::Tensor* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_u_st
  :: Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_st :: Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_st Ptr Scalar
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u(
    *$(at::Scalar* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_u_ts
  :: Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_ts :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_ts Ptr Tensor
_x Ptr Scalar
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u(
    *$(at::Tensor* _x)
  , *$(at::Scalar* _n)));
  }|]

special_chebyshev_polynomial_u_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_out_ttt Ptr Tensor
_out Ptr Tensor
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_u_out_tst
  :: Ptr Tensor
  -> Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_out_tst :: Ptr Tensor -> Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_out_tst Ptr Tensor
_out Ptr Scalar
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u_out(
    *$(at::Tensor* _out)
  , *$(at::Scalar* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_u_out_tts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_out_tts :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
special_chebyshev_polynomial_u_out_tts Ptr Tensor
_out Ptr Tensor
_x Ptr Scalar
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_u_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)
  , *$(at::Scalar* _n)));
  }|]

special_chebyshev_polynomial_v_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_tt Ptr Tensor
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v(
    *$(at::Tensor* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_v_st
  :: Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_st :: Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_st Ptr Scalar
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v(
    *$(at::Scalar* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_v_ts
  :: Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_ts :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_ts Ptr Tensor
_x Ptr Scalar
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v(
    *$(at::Tensor* _x)
  , *$(at::Scalar* _n)));
  }|]

special_chebyshev_polynomial_v_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_out_ttt Ptr Tensor
_out Ptr Tensor
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_v_out_tst
  :: Ptr Tensor
  -> Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_out_tst :: Ptr Tensor -> Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_out_tst Ptr Tensor
_out Ptr Scalar
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v_out(
    *$(at::Tensor* _out)
  , *$(at::Scalar* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_v_out_tts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_out_tts :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
special_chebyshev_polynomial_v_out_tts Ptr Tensor
_out Ptr Tensor
_x Ptr Scalar
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_v_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)
  , *$(at::Scalar* _n)));
  }|]

special_chebyshev_polynomial_w_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_tt Ptr Tensor
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w(
    *$(at::Tensor* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_w_st
  :: Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_st :: Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_st Ptr Scalar
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w(
    *$(at::Scalar* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_w_ts
  :: Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_ts :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_ts Ptr Tensor
_x Ptr Scalar
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w(
    *$(at::Tensor* _x)
  , *$(at::Scalar* _n)));
  }|]

special_chebyshev_polynomial_w_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_out_ttt Ptr Tensor
_out Ptr Tensor
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_w_out_tst
  :: Ptr Tensor
  -> Ptr Scalar
  -> Ptr Tensor
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_out_tst :: Ptr Tensor -> Ptr Scalar -> Ptr Tensor -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_out_tst Ptr Tensor
_out Ptr Scalar
_x Ptr Tensor
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w_out(
    *$(at::Tensor* _out)
  , *$(at::Scalar* _x)
  , *$(at::Tensor* _n)));
  }|]

special_chebyshev_polynomial_w_out_tts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_out_tts :: Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
special_chebyshev_polynomial_w_out_tts Ptr Tensor
_out Ptr Tensor
_x Ptr Scalar
_n =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::special_chebyshev_polynomial_w_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x)
  , *$(at::Scalar* _n)));
  }|]