-- generated by using spec/Declarations.yaml

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

module Torch.Internal.Unmanaged.Native.Native10 where


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

quantile_ttlbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> Ptr StdString
  -> IO (Ptr Tensor)
quantile_ttlbs :: Ptr Tensor
-> Ptr Tensor -> Int64 -> CBool -> Ptr StdString -> IO (Ptr Tensor)
quantile_ttlbs Ptr Tensor
_self Ptr Tensor
_q Int64
_dim CBool
_keepdim Ptr StdString
_interpolation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _q)
  , $(int64_t _dim)
  , $(bool _keepdim)
  , *$(std::string* _interpolation)));
  }|]

quantile_ttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
quantile_ttlb :: Ptr Tensor -> Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
quantile_ttlb Ptr Tensor
_self Ptr Tensor
_q Int64
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _q)
  , $(int64_t _dim)
  , $(bool _keepdim)));
  }|]

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

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

quantile_out_tttlbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> Ptr StdString
  -> IO (Ptr Tensor)
quantile_out_tttlbs :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> Ptr StdString
-> IO (Ptr Tensor)
quantile_out_tttlbs Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_q Int64
_dim CBool
_keepdim Ptr StdString
_interpolation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _q)
  , $(int64_t _dim)
  , $(bool _keepdim)
  , *$(std::string* _interpolation)));
  }|]

quantile_out_tttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
quantile_out_tttlb :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
quantile_out_tttlb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_q Int64
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _q)
  , $(int64_t _dim)
  , $(bool _keepdim)));
  }|]

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

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

quantile_tdlbs
  :: Ptr Tensor
  -> CDouble
  -> Int64
  -> CBool
  -> Ptr StdString
  -> IO (Ptr Tensor)
quantile_tdlbs :: Ptr Tensor
-> CDouble -> Int64 -> CBool -> Ptr StdString -> IO (Ptr Tensor)
quantile_tdlbs Ptr Tensor
_self CDouble
_q Int64
_dim CBool
_keepdim Ptr StdString
_interpolation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
    *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)
  , $(bool _keepdim)
  , *$(std::string* _interpolation)));
  }|]

quantile_tdlb
  :: Ptr Tensor
  -> CDouble
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
quantile_tdlb :: Ptr Tensor -> CDouble -> Int64 -> CBool -> IO (Ptr Tensor)
quantile_tdlb Ptr Tensor
_self CDouble
_q Int64
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile(
    *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)
  , $(bool _keepdim)));
  }|]

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

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

quantile_out_ttdlbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> CBool
  -> Ptr StdString
  -> IO (Ptr Tensor)
quantile_out_ttdlbs :: Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> CBool
-> Ptr StdString
-> IO (Ptr Tensor)
quantile_out_ttdlbs Ptr Tensor
_out Ptr Tensor
_self CDouble
_q Int64
_dim CBool
_keepdim Ptr StdString
_interpolation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)
  , $(bool _keepdim)
  , *$(std::string* _interpolation)));
  }|]

quantile_out_ttdlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
quantile_out_ttdlb :: Ptr Tensor
-> Ptr Tensor -> CDouble -> Int64 -> CBool -> IO (Ptr Tensor)
quantile_out_ttdlb Ptr Tensor
_out Ptr Tensor
_self CDouble
_q Int64
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)
  , $(bool _keepdim)));
  }|]

quantile_out_ttdl
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> IO (Ptr Tensor)
quantile_out_ttdl :: Ptr Tensor -> Ptr Tensor -> CDouble -> Int64 -> IO (Ptr Tensor)
quantile_out_ttdl Ptr Tensor
_out Ptr Tensor
_self CDouble
_q Int64
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)));
  }|]

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

nanquantile_ttlbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> Ptr StdString
  -> IO (Ptr Tensor)
nanquantile_ttlbs :: Ptr Tensor
-> Ptr Tensor -> Int64 -> CBool -> Ptr StdString -> IO (Ptr Tensor)
nanquantile_ttlbs Ptr Tensor
_self Ptr Tensor
_q Int64
_dim CBool
_keepdim Ptr StdString
_interpolation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _q)
  , $(int64_t _dim)
  , $(bool _keepdim)
  , *$(std::string* _interpolation)));
  }|]

nanquantile_ttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
nanquantile_ttlb :: Ptr Tensor -> Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
nanquantile_ttlb Ptr Tensor
_self Ptr Tensor
_q Int64
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _q)
  , $(int64_t _dim)
  , $(bool _keepdim)));
  }|]

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

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

nanquantile_out_tttlbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> Ptr StdString
  -> IO (Ptr Tensor)
nanquantile_out_tttlbs :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> Ptr StdString
-> IO (Ptr Tensor)
nanquantile_out_tttlbs Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_q Int64
_dim CBool
_keepdim Ptr StdString
_interpolation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _q)
  , $(int64_t _dim)
  , $(bool _keepdim)
  , *$(std::string* _interpolation)));
  }|]

nanquantile_out_tttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
nanquantile_out_tttlb :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
nanquantile_out_tttlb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_q Int64
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _q)
  , $(int64_t _dim)
  , $(bool _keepdim)));
  }|]

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

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

nanquantile_tdlbs
  :: Ptr Tensor
  -> CDouble
  -> Int64
  -> CBool
  -> Ptr StdString
  -> IO (Ptr Tensor)
nanquantile_tdlbs :: Ptr Tensor
-> CDouble -> Int64 -> CBool -> Ptr StdString -> IO (Ptr Tensor)
nanquantile_tdlbs Ptr Tensor
_self CDouble
_q Int64
_dim CBool
_keepdim Ptr StdString
_interpolation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
    *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)
  , $(bool _keepdim)
  , *$(std::string* _interpolation)));
  }|]

nanquantile_tdlb
  :: Ptr Tensor
  -> CDouble
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
nanquantile_tdlb :: Ptr Tensor -> CDouble -> Int64 -> CBool -> IO (Ptr Tensor)
nanquantile_tdlb Ptr Tensor
_self CDouble
_q Int64
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile(
    *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)
  , $(bool _keepdim)));
  }|]

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

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

nanquantile_out_ttdlbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> CBool
  -> Ptr StdString
  -> IO (Ptr Tensor)
nanquantile_out_ttdlbs :: Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> CBool
-> Ptr StdString
-> IO (Ptr Tensor)
nanquantile_out_ttdlbs Ptr Tensor
_out Ptr Tensor
_self CDouble
_q Int64
_dim CBool
_keepdim Ptr StdString
_interpolation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)
  , $(bool _keepdim)
  , *$(std::string* _interpolation)));
  }|]

nanquantile_out_ttdlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
nanquantile_out_ttdlb :: Ptr Tensor
-> Ptr Tensor -> CDouble -> Int64 -> CBool -> IO (Ptr Tensor)
nanquantile_out_ttdlb Ptr Tensor
_out Ptr Tensor
_self CDouble
_q Int64
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)
  , $(bool _keepdim)));
  }|]

nanquantile_out_ttdl
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> IO (Ptr Tensor)
nanquantile_out_ttdl :: Ptr Tensor -> Ptr Tensor -> CDouble -> Int64 -> IO (Ptr Tensor)
nanquantile_out_ttdl Ptr Tensor
_out Ptr Tensor
_self CDouble
_q Int64
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanquantile_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _q)
  , $(int64_t _dim)));
  }|]

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

sort_out_tttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_tttlb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_tttlb Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self Int64
_dim CBool
_descending =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(bool _descending)));
  }|]

sort_out_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_tttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_tttl Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self Int64
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

sort_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_ttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_ttt Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)));
  }|]

sort_out_tttblb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_tttblb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> Int64
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_tttblb Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self CBool
_stable Int64
_dim CBool
_descending =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(bool _stable)
  , $(int64_t _dim)
  , $(bool _descending)));
  }|]

sort_out_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_tttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_tttb Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self CBool
_stable =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(bool _stable)));
  }|]

sort_tlb
  :: Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_tlb :: Ptr Tensor
-> Int64 -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_tlb Ptr Tensor
_self Int64
_dim CBool
_descending =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
    *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(bool _descending)));
  }|]

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

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

sort_tblb
  :: Ptr Tensor
  -> CBool
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_tblb :: Ptr Tensor
-> CBool -> Int64 -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_tblb Ptr Tensor
_self CBool
_stable Int64
_dim CBool
_descending =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
    *$(at::Tensor* _self)
  , $(bool _stable)
  , $(int64_t _dim)
  , $(bool _descending)));
  }|]

-- sort_tbl
--   :: Ptr Tensor
--   -> CBool
--   -> Int64
--   -> IO (Ptr (StdTuple '(Tensor,Tensor)))
-- sort_tbl _self _stable _dim =
--   [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
--     *$(at::Tensor* _self)
--   , $(bool _stable)
--   , $(int64_t _dim)));
--   }|]

sort_tb
  :: Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_tb :: Ptr Tensor -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_tb Ptr Tensor
_self CBool
_stable =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
    *$(at::Tensor* _self)
  , $(bool _stable)));
  }|]

sort_out_tttnb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Dimname
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_tttnb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Dimname
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_tttnb Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self Ptr Dimname
_dim CBool
_descending =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)
  , $(bool _descending)));
  }|]

sort_out_tttn
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Dimname
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_tttn :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Dimname
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_tttn Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self Ptr Dimname
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)));
  }|]

sort_out_tttbnb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> Ptr Dimname
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_tttbnb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> Ptr Dimname
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_tttbnb Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self CBool
_stable Ptr Dimname
_dim CBool
_descending =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(bool _stable)
  , *$(at::Dimname* _dim)
  , $(bool _descending)));
  }|]

sort_out_tttbn
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> Ptr Dimname
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_out_tttbn :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> Ptr Dimname
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_out_tttbn Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self CBool
_stable Ptr Dimname
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(bool _stable)
  , *$(at::Dimname* _dim)));
  }|]

sort_tnb
  :: Ptr Tensor
  -> Ptr Dimname
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_tnb :: Ptr Tensor
-> Ptr Dimname -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_tnb Ptr Tensor
_self Ptr Dimname
_dim CBool
_descending =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
    *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)
  , $(bool _descending)));
  }|]

sort_tn
  :: Ptr Tensor
  -> Ptr Dimname
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_tn :: Ptr Tensor -> Ptr Dimname -> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_tn Ptr Tensor
_self Ptr Dimname
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
    *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)));
  }|]

sort_tbnb
  :: Ptr Tensor
  -> CBool
  -> Ptr Dimname
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_tbnb :: Ptr Tensor
-> CBool
-> Ptr Dimname
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_tbnb Ptr Tensor
_self CBool
_stable Ptr Dimname
_dim CBool
_descending =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
    *$(at::Tensor* _self)
  , $(bool _stable)
  , *$(at::Dimname* _dim)
  , $(bool _descending)));
  }|]

sort_tbn
  :: Ptr Tensor
  -> CBool
  -> Ptr Dimname
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
sort_tbn :: Ptr Tensor
-> CBool -> Ptr Dimname -> IO (Ptr (StdTuple '(Tensor, Tensor)))
sort_tbn Ptr Tensor
_self CBool
_stable Ptr Dimname
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::sort(
    *$(at::Tensor* _self)
  , $(bool _stable)
  , *$(at::Dimname* _dim)));
  }|]

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

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

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

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

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

argsort_tnb
  :: Ptr Tensor
  -> Ptr Dimname
  -> CBool
  -> IO (Ptr Tensor)
argsort_tnb :: Ptr Tensor -> Ptr Dimname -> CBool -> IO (Ptr Tensor)
argsort_tnb Ptr Tensor
_self Ptr Dimname
_dim CBool
_descending =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
    *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)
  , $(bool _descending)));
  }|]

argsort_tn
  :: Ptr Tensor
  -> Ptr Dimname
  -> IO (Ptr Tensor)
argsort_tn :: Ptr Tensor -> Ptr Dimname -> IO (Ptr Tensor)
argsort_tn Ptr Tensor
_self Ptr Dimname
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::argsort(
    *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)));
  }|]

topk_out_tttllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
topk_out_tttllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
topk_out_tttllbb Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self Int64
_k Int64
_dim CBool
_largest CBool
_sorted =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _k)
  , $(int64_t _dim)
  , $(bool _largest)
  , $(bool _sorted)));
  }|]

topk_out_tttllb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
topk_out_tttllb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
topk_out_tttllb Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self Int64
_k Int64
_dim CBool
_largest =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _k)
  , $(int64_t _dim)
  , $(bool _largest)));
  }|]

topk_out_tttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
topk_out_tttll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
topk_out_tttll Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self Int64
_k Int64
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _k)
  , $(int64_t _dim)));
  }|]

topk_out_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
topk_out_tttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
topk_out_tttl Ptr Tensor
_values Ptr Tensor
_indices Ptr Tensor
_self Int64
_k =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _k)));
  }|]

topk_tllbb
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
topk_tllbb :: Ptr Tensor
-> Int64
-> Int64
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
topk_tllbb Ptr Tensor
_self Int64
_k Int64
_dim CBool
_largest CBool
_sorted =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk(
    *$(at::Tensor* _self)
  , $(int64_t _k)
  , $(int64_t _dim)
  , $(bool _largest)
  , $(bool _sorted)));
  }|]

topk_tllb
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
topk_tllb :: Ptr Tensor
-> Int64 -> Int64 -> CBool -> IO (Ptr (StdTuple '(Tensor, Tensor)))
topk_tllb Ptr Tensor
_self Int64
_k Int64
_dim CBool
_largest =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk(
    *$(at::Tensor* _self)
  , $(int64_t _k)
  , $(int64_t _dim)
  , $(bool _largest)));
  }|]

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

topk_tl
  :: Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
topk_tl :: Ptr Tensor -> Int64 -> IO (Ptr (StdTuple '(Tensor, Tensor)))
topk_tl Ptr Tensor
_self Int64
_k =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::topk(
    *$(at::Tensor* _self)
  , $(int64_t _k)));
  }|]

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

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

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

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

renorm_out_ttsls
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> Int64
  -> Ptr Scalar
  -> IO (Ptr Tensor)
renorm_out_ttsls :: Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Int64
-> Ptr Scalar
-> IO (Ptr Tensor)
renorm_out_ttsls Ptr Tensor
_out Ptr Tensor
_self Ptr Scalar
_p Int64
_dim Ptr Scalar
_maxnorm =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::renorm_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Scalar* _p)
  , $(int64_t _dim)
  , *$(at::Scalar* _maxnorm)));
  }|]

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

unfold_backward_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
unfold_backward_tllll :: Ptr Tensor
-> Ptr IntArray -> Int64 -> Int64 -> Int64 -> IO (Ptr Tensor)
unfold_backward_tllll Ptr Tensor
_grad_in Ptr IntArray
_input_sizes Int64
_dim Int64
_size Int64
_step =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::unfold_backward(
    *$(at::Tensor* _grad_in)
  , *$(std::vector<int64_t>* _input_sizes)
  , $(int64_t _dim)
  , $(int64_t _size)
  , $(int64_t _step)));
  }|]

equal_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (CBool)
equal_tt :: Ptr Tensor -> Ptr Tensor -> IO CBool
equal_tt Ptr Tensor
_self Ptr Tensor
_other =
  [C.throwBlock| bool { return (at::equal(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _other)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

normal_out_ttdG
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Ptr Generator
  -> IO (Ptr Tensor)
normal_out_ttdG :: Ptr Tensor
-> Ptr Tensor -> CDouble -> Ptr Generator -> IO (Ptr Tensor)
normal_out_ttdG Ptr Tensor
_out Ptr Tensor
_mean CDouble
_std Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _mean)
  , $(double _std)
  , *$(at::Generator* _generator)));
  }|]

normal_out_ttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
normal_out_ttd :: Ptr Tensor -> Ptr Tensor -> CDouble -> IO (Ptr Tensor)
normal_out_ttd Ptr Tensor
_out Ptr Tensor
_mean CDouble
_std =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _mean)
  , $(double _std)));
  }|]

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

normal_tdG
  :: Ptr Tensor
  -> CDouble
  -> Ptr Generator
  -> IO (Ptr Tensor)
normal_tdG :: Ptr Tensor -> CDouble -> Ptr Generator -> IO (Ptr Tensor)
normal_tdG Ptr Tensor
_mean CDouble
_std Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    *$(at::Tensor* _mean)
  , $(double _std)
  , *$(at::Generator* _generator)));
  }|]

normal_td
  :: Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
normal_td :: Ptr Tensor -> CDouble -> IO (Ptr Tensor)
normal_td Ptr Tensor
_mean CDouble
_std =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    *$(at::Tensor* _mean)
  , $(double _std)));
  }|]

normal_t
  :: Ptr Tensor
  -> IO (Ptr Tensor)
normal_t :: Ptr Tensor -> IO (Ptr Tensor)
normal_t Ptr Tensor
_mean =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    *$(at::Tensor* _mean)));
  }|]

normal_out_tdtG
  :: Ptr Tensor
  -> CDouble
  -> Ptr Tensor
  -> Ptr Generator
  -> IO (Ptr Tensor)
normal_out_tdtG :: Ptr Tensor
-> CDouble -> Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
normal_out_tdtG Ptr Tensor
_out CDouble
_mean Ptr Tensor
_std Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
    *$(at::Tensor* _out)
  , $(double _mean)
  , *$(at::Tensor* _std)
  , *$(at::Generator* _generator)));
  }|]

normal_out_tdt
  :: Ptr Tensor
  -> CDouble
  -> Ptr Tensor
  -> IO (Ptr Tensor)
normal_out_tdt :: Ptr Tensor -> CDouble -> Ptr Tensor -> IO (Ptr Tensor)
normal_out_tdt Ptr Tensor
_out CDouble
_mean Ptr Tensor
_std =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
    *$(at::Tensor* _out)
  , $(double _mean)
  , *$(at::Tensor* _std)));
  }|]

normal_dtG
  :: CDouble
  -> Ptr Tensor
  -> Ptr Generator
  -> IO (Ptr Tensor)
normal_dtG :: CDouble -> Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
normal_dtG CDouble
_mean Ptr Tensor
_std Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    $(double _mean)
  , *$(at::Tensor* _std)
  , *$(at::Generator* _generator)));
  }|]

normal_dt
  :: CDouble
  -> Ptr Tensor
  -> IO (Ptr Tensor)
normal_dt :: CDouble -> Ptr Tensor -> IO (Ptr Tensor)
normal_dt CDouble
_mean Ptr Tensor
_std =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    $(double _mean)
  , *$(at::Tensor* _std)));
  }|]

normal_out_tttG
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Generator
  -> IO (Ptr Tensor)
normal_out_tttG :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
normal_out_tttG Ptr Tensor
_out Ptr Tensor
_mean Ptr Tensor
_std Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _mean)
  , *$(at::Tensor* _std)
  , *$(at::Generator* _generator)));
  }|]

normal_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
normal_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
normal_out_ttt Ptr Tensor
_out Ptr Tensor
_mean Ptr Tensor
_std =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _mean)
  , *$(at::Tensor* _std)));
  }|]

normal_ttG
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Generator
  -> IO (Ptr Tensor)
normal_ttG :: Ptr Tensor -> Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
normal_ttG Ptr Tensor
_mean Ptr Tensor
_std Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    *$(at::Tensor* _mean)
  , *$(at::Tensor* _std)
  , *$(at::Generator* _generator)));
  }|]

normal_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
normal_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
normal_tt Ptr Tensor
_mean Ptr Tensor
_std =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    *$(at::Tensor* _mean)
  , *$(at::Tensor* _std)));
  }|]

normal_ddlGo
  :: CDouble
  -> CDouble
  -> Ptr IntArray
  -> Ptr Generator
  -> Ptr TensorOptions
  -> IO (Ptr Tensor)
normal_ddlGo :: CDouble
-> CDouble
-> Ptr IntArray
-> Ptr Generator
-> Ptr TensorOptions
-> IO (Ptr Tensor)
normal_ddlGo CDouble
_mean CDouble
_std Ptr IntArray
_size Ptr Generator
_generator Ptr TensorOptions
_options =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    $(double _mean)
  , $(double _std)
  , *$(std::vector<int64_t>* _size)
  , *$(at::Generator* _generator)
  , *$(at::TensorOptions* _options)));
  }|]

normal_ddlG
  :: CDouble
  -> CDouble
  -> Ptr IntArray
  -> Ptr Generator
  -> IO (Ptr Tensor)
normal_ddlG :: CDouble
-> CDouble -> Ptr IntArray -> Ptr Generator -> IO (Ptr Tensor)
normal_ddlG CDouble
_mean CDouble
_std Ptr IntArray
_size Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    $(double _mean)
  , $(double _std)
  , *$(std::vector<int64_t>* _size)
  , *$(at::Generator* _generator)));
  }|]

normal_ddl
  :: CDouble
  -> CDouble
  -> Ptr IntArray
  -> IO (Ptr Tensor)
normal_ddl :: CDouble -> CDouble -> Ptr IntArray -> IO (Ptr Tensor)
normal_ddl CDouble
_mean CDouble
_std Ptr IntArray
_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal(
    $(double _mean)
  , $(double _std)
  , *$(std::vector<int64_t>* _size)));
  }|]

normal_out_tddlG
  :: Ptr Tensor
  -> CDouble
  -> CDouble
  -> Ptr IntArray
  -> Ptr Generator
  -> IO (Ptr Tensor)
normal_out_tddlG :: Ptr Tensor
-> CDouble
-> CDouble
-> Ptr IntArray
-> Ptr Generator
-> IO (Ptr Tensor)
normal_out_tddlG Ptr Tensor
_out CDouble
_mean CDouble
_std Ptr IntArray
_size Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
    *$(at::Tensor* _out)
  , $(double _mean)
  , $(double _std)
  , *$(std::vector<int64_t>* _size)
  , *$(at::Generator* _generator)));
  }|]

normal_out_tddl
  :: Ptr Tensor
  -> CDouble
  -> CDouble
  -> Ptr IntArray
  -> IO (Ptr Tensor)
normal_out_tddl :: Ptr Tensor -> CDouble -> CDouble -> Ptr IntArray -> IO (Ptr Tensor)
normal_out_tddl Ptr Tensor
_out CDouble
_mean CDouble
_std Ptr IntArray
_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::normal_out(
    *$(at::Tensor* _out)
  , $(double _mean)
  , $(double _std)
  , *$(std::vector<int64_t>* _size)));
  }|]

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

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

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

_amp_update_scale__tttddl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CDouble
  -> Int64
  -> IO (Ptr Tensor)
_amp_update_scale__tttddl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> CDouble
-> Int64
-> IO (Ptr Tensor)
_amp_update_scale__tttddl Ptr Tensor
_self Ptr Tensor
_growth_tracker Ptr Tensor
_found_inf CDouble
_scale_growth_factor CDouble
_scale_backoff_factor Int64
_growth_interval =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_amp_update_scale_(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _growth_tracker)
  , *$(at::Tensor* _found_inf)
  , $(double _scale_growth_factor)
  , $(double _scale_backoff_factor)
  , $(int64_t _growth_interval)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

_foreach_add__lls
  :: Ptr TensorList
  -> Ptr TensorList
  -> Ptr Scalar
  -> IO (())
_foreach_add__lls :: Ptr TensorList -> Ptr TensorList -> Ptr Scalar -> IO ()
_foreach_add__lls Ptr TensorList
_self Ptr TensorList
_other Ptr Scalar
_alpha =
  [C.throwBlock| void {  (at::_foreach_add_(
    *$(std::vector<at::Tensor>* _self)
  , *$(std::vector<at::Tensor>* _other)
  , *$(at::Scalar* _alpha)));
  }|]

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

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

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

_foreach_sub__lls
  :: Ptr TensorList
  -> Ptr TensorList
  -> Ptr Scalar
  -> IO (())
_foreach_sub__lls :: Ptr TensorList -> Ptr TensorList -> Ptr Scalar -> IO ()
_foreach_sub__lls Ptr TensorList
_self Ptr TensorList
_other Ptr Scalar
_alpha =
  [C.throwBlock| void {  (at::_foreach_sub_(
    *$(std::vector<at::Tensor>* _self)
  , *$(std::vector<at::Tensor>* _other)
  , *$(at::Scalar* _alpha)));
  }|]

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

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

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

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

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

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

_foreach_add__lA
  :: Ptr TensorList
  -> Ptr (StdVector Scalar)
  -> IO (())
_foreach_add__lA :: Ptr TensorList -> Ptr (StdVector Scalar) -> IO ()
_foreach_add__lA Ptr TensorList
_self Ptr (StdVector Scalar)
_scalars =
  [C.throwBlock| void {  (at::_foreach_add_(
    *$(std::vector<at::Tensor>* _self)
  , *$(std::vector<at::Scalar>* _scalars)));
  }|]

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

_foreach_sub__lA
  :: Ptr TensorList
  -> Ptr (StdVector Scalar)
  -> IO (())
_foreach_sub__lA :: Ptr TensorList -> Ptr (StdVector Scalar) -> IO ()
_foreach_sub__lA Ptr TensorList
_self Ptr (StdVector Scalar)
_scalars =
  [C.throwBlock| void {  (at::_foreach_sub_(
    *$(std::vector<at::Tensor>* _self)
  , *$(std::vector<at::Scalar>* _scalars)));
  }|]

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

_foreach_div__lA
  :: Ptr TensorList
  -> Ptr (StdVector Scalar)
  -> IO (())
_foreach_div__lA :: Ptr TensorList -> Ptr (StdVector Scalar) -> IO ()
_foreach_div__lA Ptr TensorList
_self Ptr (StdVector Scalar)
_scalars =
  [C.throwBlock| void {  (at::_foreach_div_(
    *$(std::vector<at::Tensor>* _self)
  , *$(std::vector<at::Scalar>* _scalars)));
  }|]

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

_foreach_mul__lA
  :: Ptr TensorList
  -> Ptr (StdVector Scalar)
  -> IO (())
_foreach_mul__lA :: Ptr TensorList -> Ptr (StdVector Scalar) -> IO ()
_foreach_mul__lA Ptr TensorList
_self Ptr (StdVector Scalar)
_scalars =
  [C.throwBlock| void {  (at::_foreach_mul_(
    *$(std::vector<at::Tensor>* _self)
  , *$(std::vector<at::Scalar>* _scalars)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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