-- generated by using spec/Declarations.yaml

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

module Torch.Internal.Unmanaged.Native.Native4 where


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

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

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

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


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

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

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

logspace_ssldo
  :: Ptr Scalar
  -> Ptr Scalar
  -> Int64
  -> CDouble
  -> Ptr TensorOptions
  -> IO (Ptr Tensor)
logspace_ssldo :: Ptr Scalar
-> Ptr Scalar
-> Int64
-> CDouble
-> Ptr TensorOptions
-> IO (Ptr Tensor)
logspace_ssldo Ptr Scalar
_start Ptr Scalar
_end Int64
_steps CDouble
_base Ptr TensorOptions
_options =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace(
    *$(at::Scalar* _start)
  , *$(at::Scalar* _end)
  , $(int64_t _steps)
  , $(double _base)
  , *$(at::TensorOptions* _options)));
  }|]

logspace_ssld
  :: Ptr Scalar
  -> Ptr Scalar
  -> Int64
  -> CDouble
  -> IO (Ptr Tensor)
logspace_ssld :: Ptr Scalar -> Ptr Scalar -> Int64 -> CDouble -> IO (Ptr Tensor)
logspace_ssld Ptr Scalar
_start Ptr Scalar
_end Int64
_steps CDouble
_base =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace(
    *$(at::Scalar* _start)
  , *$(at::Scalar* _end)
  , $(int64_t _steps)
  , $(double _base)));
  }|]

logspace_ssl
  :: Ptr Scalar
  -> Ptr Scalar
  -> Int64
  -> IO (Ptr Tensor)
logspace_ssl :: Ptr Scalar -> Ptr Scalar -> Int64 -> IO (Ptr Tensor)
logspace_ssl Ptr Scalar
_start Ptr Scalar
_end Int64
_steps =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace(
    *$(at::Scalar* _start)
  , *$(at::Scalar* _end)
  , $(int64_t _steps)));
  }|]

logspace_out_tssld
  :: Ptr Tensor
  -> Ptr Scalar
  -> Ptr Scalar
  -> Int64
  -> CDouble
  -> IO (Ptr Tensor)
logspace_out_tssld :: Ptr Tensor
-> Ptr Scalar -> Ptr Scalar -> Int64 -> CDouble -> IO (Ptr Tensor)
logspace_out_tssld Ptr Tensor
_out Ptr Scalar
_start Ptr Scalar
_end Int64
_steps CDouble
_base =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace_out(
    *$(at::Tensor* _out)
  , *$(at::Scalar* _start)
  , *$(at::Scalar* _end)
  , $(int64_t _steps)
  , $(double _base)));
  }|]

logspace_out_tssl
  :: Ptr Tensor
  -> Ptr Scalar
  -> Ptr Scalar
  -> Int64
  -> IO (Ptr Tensor)
logspace_out_tssl :: Ptr Tensor -> Ptr Scalar -> Ptr Scalar -> Int64 -> IO (Ptr Tensor)
logspace_out_tssl Ptr Tensor
_out Ptr Scalar
_start Ptr Scalar
_end Int64
_steps =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logspace_out(
    *$(at::Tensor* _out)
  , *$(at::Scalar* _start)
  , *$(at::Scalar* _end)
  , $(int64_t _steps)));
  }|]

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

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

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

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

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

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

_log_softmax_backward_data_ttls
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> ScalarType
  -> IO (Ptr Tensor)
_log_softmax_backward_data_ttls :: Ptr Tensor -> Ptr Tensor -> Int64 -> ScalarType -> IO (Ptr Tensor)
_log_softmax_backward_data_ttls Ptr Tensor
_grad_output Ptr Tensor
_output Int64
_dim ScalarType
_input_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_log_softmax_backward_data(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , $(int64_t _dim)
  , $(at::ScalarType _input_dtype)));
  }|]

_log_softmax_backward_data_out_tttls
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> ScalarType
  -> IO (Ptr Tensor)
_log_softmax_backward_data_out_tttls :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> ScalarType
-> IO (Ptr Tensor)
_log_softmax_backward_data_out_tttls Ptr Tensor
_out Ptr Tensor
_grad_output Ptr Tensor
_output Int64
_dim ScalarType
_input_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_log_softmax_backward_data_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , $(int64_t _dim)
  , $(at::ScalarType _input_dtype)));
  }|]

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

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

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

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

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

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

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

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

logsumexp_out_ttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
logsumexp_out_ttlb :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
logsumexp_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)));
  }|]

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

logsumexp_tNb
  :: Ptr Tensor
  -> Ptr DimnameList
  -> CBool
  -> IO (Ptr Tensor)
logsumexp_tNb :: Ptr Tensor -> Ptr DimnameList -> CBool -> IO (Ptr Tensor)
logsumexp_tNb Ptr Tensor
_self Ptr DimnameList
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp(
    *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)
  , $(bool _keepdim)));
  }|]

logsumexp_tN
  :: Ptr Tensor
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
logsumexp_tN :: Ptr Tensor -> Ptr DimnameList -> IO (Ptr Tensor)
logsumexp_tN Ptr Tensor
_self Ptr DimnameList
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp(
    *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)));
  }|]

logsumexp_out_ttNb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr DimnameList
  -> CBool
  -> IO (Ptr Tensor)
logsumexp_out_ttNb :: Ptr Tensor
-> Ptr Tensor -> Ptr DimnameList -> CBool -> IO (Ptr Tensor)
logsumexp_out_ttNb Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)
  , $(bool _keepdim)));
  }|]

logsumexp_out_ttN
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
logsumexp_out_ttN :: Ptr Tensor -> Ptr Tensor -> Ptr DimnameList -> IO (Ptr Tensor)
logsumexp_out_ttN Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::logsumexp_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)));
  }|]

margin_ranking_loss_tttdl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> IO (Ptr Tensor)
margin_ranking_loss_tttdl :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> CDouble -> Int64 -> IO (Ptr Tensor)
margin_ranking_loss_tttdl Ptr Tensor
_input1 Ptr Tensor
_input2 Ptr Tensor
_target CDouble
_margin Int64
_reduction =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::margin_ranking_loss(
    *$(at::Tensor* _input1)
  , *$(at::Tensor* _input2)
  , *$(at::Tensor* _target)
  , $(double _margin)
  , $(int64_t _reduction)));
  }|]

margin_ranking_loss_tttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
margin_ranking_loss_tttd :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> CDouble -> IO (Ptr Tensor)
margin_ranking_loss_tttd Ptr Tensor
_input1 Ptr Tensor
_input2 Ptr Tensor
_target CDouble
_margin =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::margin_ranking_loss(
    *$(at::Tensor* _input1)
  , *$(at::Tensor* _input2)
  , *$(at::Tensor* _target)
  , $(double _margin)));
  }|]

margin_ranking_loss_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
margin_ranking_loss_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
margin_ranking_loss_ttt Ptr Tensor
_input1 Ptr Tensor
_input2 Ptr Tensor
_target =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::margin_ranking_loss(
    *$(at::Tensor* _input1)
  , *$(at::Tensor* _input2)
  , *$(at::Tensor* _target)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

value_selecting_reduction_backward_tltlb
  :: Ptr Tensor
  -> Int64
  -> Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
value_selecting_reduction_backward_tltlb :: Ptr Tensor
-> Int64 -> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
value_selecting_reduction_backward_tltlb Ptr Tensor
_grad Int64
_dim Ptr Tensor
_indices Ptr IntArray
_sizes CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::value_selecting_reduction_backward(
    *$(at::Tensor* _grad)
  , $(int64_t _dim)
  , *$(at::Tensor* _indices)
  , *$(std::vector<int64_t>* _sizes)
  , $(bool _keepdim)));
  }|]

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

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

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

amax_out_ttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
amax_out_ttlb :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
amax_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amax_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)));
  }|]

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

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

max_pool1d_with_indices_tllllb
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
max_pool1d_with_indices_tllllb :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
max_pool1d_with_indices_tllllb Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

max_pool1d_with_indices_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
max_pool1d_with_indices_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
max_pool1d_with_indices_tllll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

max_pool1d_with_indices_tlll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
max_pool1d_with_indices_tlll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
max_pool1d_with_indices_tlll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)));
  }|]

max_pool1d_with_indices_tll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
max_pool1d_with_indices_tll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
max_pool1d_with_indices_tll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)));
  }|]

max_pool1d_with_indices_tl
  :: Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
max_pool1d_with_indices_tl :: Ptr Tensor -> Ptr IntArray -> IO (Ptr (StdTuple '(Tensor, Tensor)))
max_pool1d_with_indices_tl Ptr Tensor
_self Ptr IntArray
_kernel_size =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::max_pool1d_with_indices(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)));
  }|]

max_pool1d_tllllb
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
max_pool1d_tllllb :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
max_pool1d_tllllb Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool1d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

max_pool1d_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
max_pool1d_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
max_pool1d_tllll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool1d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

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

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

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

max_pool2d_tllllb
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
max_pool2d_tllllb :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
max_pool2d_tllllb Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

max_pool2d_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
max_pool2d_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
max_pool2d_tllll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool2d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

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

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

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

mkldnn_max_pool2d_tllllb
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
mkldnn_max_pool2d_tllllb :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
mkldnn_max_pool2d_tllllb Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

mkldnn_max_pool2d_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool2d_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
mkldnn_max_pool2d_tllll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

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

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

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

mkldnn_max_pool2d_backward_tttllllb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttllllb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttllllb Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

mkldnn_max_pool2d_backward_tttllll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttllll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttllll Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

mkldnn_max_pool2d_backward_tttlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttlll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttlll Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)));
  }|]

mkldnn_max_pool2d_backward_tttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttll Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size Ptr IntArray
_stride =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)));
  }|]

mkldnn_max_pool2d_backward_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttl :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
mkldnn_max_pool2d_backward_tttl Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool2d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)));
  }|]

mkldnn_max_pool3d_tllllb
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
mkldnn_max_pool3d_tllllb :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
mkldnn_max_pool3d_tllllb Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

mkldnn_max_pool3d_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool3d_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
mkldnn_max_pool3d_tllll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

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

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

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

mkldnn_max_pool3d_backward_tttllllb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttllllb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttllllb Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

mkldnn_max_pool3d_backward_tttllll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttllll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttllll Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

mkldnn_max_pool3d_backward_tttlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttlll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttlll Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)));
  }|]

mkldnn_max_pool3d_backward_tttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttll Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size Ptr IntArray
_stride =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)));
  }|]

mkldnn_max_pool3d_backward_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttl :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
mkldnn_max_pool3d_backward_tttl Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_input Ptr IntArray
_kernel_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_max_pool3d_backward(
    *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _input)
  , *$(std::vector<int64_t>* _kernel_size)));
  }|]

quantized_max_pool1d_tllllb
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
quantized_max_pool1d_tllllb :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
quantized_max_pool1d_tllllb Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

quantized_max_pool1d_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
quantized_max_pool1d_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
quantized_max_pool1d_tllll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool1d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

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

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

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

quantized_max_pool2d_tllllb
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
quantized_max_pool2d_tllllb :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
quantized_max_pool2d_tllllb Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

quantized_max_pool2d_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
quantized_max_pool2d_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
quantized_max_pool2d_tllll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantized_max_pool2d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

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

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

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

max_pool3d_tllllb
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
max_pool3d_tllllb :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> CBool
-> IO (Ptr Tensor)
max_pool3d_tllllb Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation CBool
_ceil_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)
  , $(bool _ceil_mode)));
  }|]

max_pool3d_tllll
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
max_pool3d_tllll :: Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
max_pool3d_tllll Ptr Tensor
_self Ptr IntArray
_kernel_size Ptr IntArray
_stride Ptr IntArray
_padding Ptr IntArray
_dilation =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::max_pool3d(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _kernel_size)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _dilation)));
  }|]

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

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

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

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

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

mean_tlbs
  :: Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> ScalarType
  -> IO (Ptr Tensor)
mean_tlbs :: Ptr Tensor
-> Ptr IntArray -> CBool -> ScalarType -> IO (Ptr Tensor)
mean_tlbs Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim ScalarType
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)
  , $(at::ScalarType _dtype)));
  }|]

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

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

mean_out_ttlbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> ScalarType
  -> IO (Ptr Tensor)
mean_out_ttlbs :: Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> CBool
-> ScalarType
-> IO (Ptr Tensor)
mean_out_ttlbs Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim ScalarType
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)
  , $(at::ScalarType _dtype)));
  }|]

mean_out_ttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
mean_out_ttlb :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
mean_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)));
  }|]

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

mean_tNbs
  :: Ptr Tensor
  -> Ptr DimnameList
  -> CBool
  -> ScalarType
  -> IO (Ptr Tensor)
mean_tNbs :: Ptr Tensor
-> Ptr DimnameList -> CBool -> ScalarType -> IO (Ptr Tensor)
mean_tNbs Ptr Tensor
_self Ptr DimnameList
_dim CBool
_keepdim ScalarType
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
    *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)
  , $(bool _keepdim)
  , $(at::ScalarType _dtype)));
  }|]

mean_tNb
  :: Ptr Tensor
  -> Ptr DimnameList
  -> CBool
  -> IO (Ptr Tensor)
mean_tNb :: Ptr Tensor -> Ptr DimnameList -> CBool -> IO (Ptr Tensor)
mean_tNb Ptr Tensor
_self Ptr DimnameList
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
    *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)
  , $(bool _keepdim)));
  }|]

mean_tN
  :: Ptr Tensor
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
mean_tN :: Ptr Tensor -> Ptr DimnameList -> IO (Ptr Tensor)
mean_tN Ptr Tensor
_self Ptr DimnameList
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean(
    *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)));
  }|]

mean_out_ttNbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr DimnameList
  -> CBool
  -> ScalarType
  -> IO (Ptr Tensor)
mean_out_ttNbs :: Ptr Tensor
-> Ptr Tensor
-> Ptr DimnameList
-> CBool
-> ScalarType
-> IO (Ptr Tensor)
mean_out_ttNbs Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim CBool
_keepdim ScalarType
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)
  , $(bool _keepdim)
  , $(at::ScalarType _dtype)));
  }|]

mean_out_ttNb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr DimnameList
  -> CBool
  -> IO (Ptr Tensor)
mean_out_ttNb :: Ptr Tensor
-> Ptr Tensor -> Ptr DimnameList -> CBool -> IO (Ptr Tensor)
mean_out_ttNb Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)
  , $(bool _keepdim)));
  }|]

mean_out_ttN
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
mean_out_ttN :: Ptr Tensor -> Ptr Tensor -> Ptr DimnameList -> IO (Ptr Tensor)
mean_out_ttN Ptr Tensor
_out Ptr Tensor
_self Ptr DimnameList
_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mean_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<at::Dimname>* _dim)));
  }|]

nanmean_tlbs
  :: Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> ScalarType
  -> IO (Ptr Tensor)
nanmean_tlbs :: Ptr Tensor
-> Ptr IntArray -> CBool -> ScalarType -> IO (Ptr Tensor)
nanmean_tlbs Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim ScalarType
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean(
    *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)
  , $(at::ScalarType _dtype)));
  }|]

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

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

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

nanmean_out_ttlbs
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> ScalarType
  -> IO (Ptr Tensor)
nanmean_out_ttlbs :: Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> CBool
-> ScalarType
-> IO (Ptr Tensor)
nanmean_out_ttlbs Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim ScalarType
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)
  , $(at::ScalarType _dtype)));
  }|]

nanmean_out_ttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
nanmean_out_ttlb :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
nanmean_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::nanmean_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)));
  }|]

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

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

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

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

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

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

median_out_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
median_out_tttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
median_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::median_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

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

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

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

median_out_tttn
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Dimname
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
median_out_tttn :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Dimname
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
median_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::median_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)));
  }|]

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

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

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

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

nanmedian_out_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
nanmedian_out_tttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
nanmedian_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::nanmedian_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

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

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

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

nanmedian_out_tttn
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Dimname
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
nanmedian_out_tttn :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Dimname
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
nanmedian_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::nanmedian_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

amin_out_ttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> CBool
  -> IO (Ptr Tensor)
amin_out_ttlb :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> CBool -> IO (Ptr Tensor)
amin_out_ttlb Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_dim CBool
_keepdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::amin_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(bool _keepdim)));
  }|]

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

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

mkldnn_convolution_tttllll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> IO (Ptr Tensor)
mkldnn_convolution_tttllll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> IO (Ptr Tensor)
mkldnn_convolution_tttllll Ptr Tensor
_self Ptr Tensor
_weight Ptr Tensor
_bias Ptr IntArray
_padding Ptr IntArray
_stride Ptr IntArray
_dilation Int64
_groups =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::mkldnn_convolution(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _dilation)
  , $(int64_t _groups)));
  }|]

miopen_batch_norm_tttttbdd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CDouble
  -> CDouble
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
miopen_batch_norm_tttttbdd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CDouble
-> CDouble
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
miopen_batch_norm_tttttbdd Ptr Tensor
_input Ptr Tensor
_weight Ptr Tensor
_bias Ptr Tensor
_running_mean Ptr Tensor
_running_var CBool
_training CDouble
_exponential_average_factor CDouble
_epsilon =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::miopen_batch_norm(
    *$(at::Tensor* _input)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(at::Tensor* _running_mean)
  , *$(at::Tensor* _running_var)
  , $(bool _training)
  , $(double _exponential_average_factor)
  , $(double _epsilon)));
  }|]

miopen_batch_norm_backward_tttttttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
miopen_batch_norm_backward_tttttttd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
miopen_batch_norm_backward_tttttttd Ptr Tensor
_input Ptr Tensor
_grad_output Ptr Tensor
_weight Ptr Tensor
_running_mean Ptr Tensor
_running_var Ptr Tensor
_save_mean Ptr Tensor
_save_var CDouble
_epsilon =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::miopen_batch_norm_backward(
    *$(at::Tensor* _input)
  , *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _running_mean)
  , *$(at::Tensor* _running_var)
  , *$(at::Tensor* _save_mean)
  , *$(at::Tensor* _save_var)
  , $(double _epsilon)));
  }|]

miopen_convolution_tttllllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr Tensor)
miopen_convolution_tttllllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> CBool
-> CBool
-> IO (Ptr Tensor)
miopen_convolution_tttllllbb Ptr Tensor
_self Ptr Tensor
_weight Ptr Tensor
_bias Ptr IntArray
_padding Ptr IntArray
_stride Ptr IntArray
_dilation Int64
_groups CBool
_benchmark CBool
_deterministic =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_convolution(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _dilation)
  , $(int64_t _groups)
  , $(bool _benchmark)
  , $(bool _deterministic)));
  }|]

miopen_convolution_transpose_tttlllllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr Tensor)
miopen_convolution_transpose_tttlllllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> CBool
-> CBool
-> IO (Ptr Tensor)
miopen_convolution_transpose_tttlllllbb Ptr Tensor
_self Ptr Tensor
_weight Ptr Tensor
_bias Ptr IntArray
_padding Ptr IntArray
_output_padding Ptr IntArray
_stride Ptr IntArray
_dilation Int64
_groups CBool
_benchmark CBool
_deterministic =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_convolution_transpose(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _output_padding)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _dilation)
  , $(int64_t _groups)
  , $(bool _benchmark)
  , $(bool _deterministic)));
  }|]

miopen_depthwise_convolution_tttllllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr Tensor)
miopen_depthwise_convolution_tttllllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> CBool
-> CBool
-> IO (Ptr Tensor)
miopen_depthwise_convolution_tttllllbb Ptr Tensor
_self Ptr Tensor
_weight Ptr Tensor
_bias Ptr IntArray
_padding Ptr IntArray
_stride Ptr IntArray
_dilation Int64
_groups CBool
_benchmark CBool
_deterministic =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::miopen_depthwise_convolution(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _stride)
  , *$(std::vector<int64_t>* _dilation)
  , $(int64_t _groups)
  , $(bool _benchmark)
  , $(bool _deterministic)));
  }|]

miopen_rnn_tllttlllbdbblt
  :: Ptr Tensor
  -> Ptr TensorList
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> CBool
  -> CDouble
  -> CBool
  -> CBool
  -> Ptr IntArray
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
miopen_rnn_tllttlllbdbblt :: Ptr Tensor
-> Ptr TensorList
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Int64
-> CBool
-> CDouble
-> CBool
-> CBool
-> Ptr IntArray
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor, Tensor)))
miopen_rnn_tllttlllbdbblt Ptr Tensor
_input Ptr TensorList
_weight Int64
_weight_stride0 Ptr Tensor
_hx Ptr Tensor
_cx Int64
_mode Int64
_hidden_size Int64
_num_layers CBool
_batch_first CDouble
_dropout CBool
_train CBool
_bidirectional Ptr IntArray
_batch_sizes Ptr Tensor
_dropout_state =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::miopen_rnn(
    *$(at::Tensor* _input)
  , *$(std::vector<at::Tensor>* _weight)
  , $(int64_t _weight_stride0)
  , *$(at::Tensor* _hx)
  , *$(at::Tensor* _cx)
  , $(int64_t _mode)
  , $(int64_t _hidden_size)
  , $(int64_t _num_layers)
  , $(bool _batch_first)
  , $(double _dropout)
  , $(bool _train)
  , $(bool _bidirectional)
  , *$(std::vector<int64_t>* _batch_sizes)
  , *$(at::Tensor* _dropout_state)));
  }|]

miopen_rnn_backward_tlltttttttlllbdbbltta
  :: Ptr Tensor
  -> Ptr TensorList
  -> Int64
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> CBool
  -> CDouble
  -> CBool
  -> CBool
  -> Ptr IntArray
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr (StdArray '(CBool,4))
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,TensorList)))
miopen_rnn_backward_tlltttttttlllbdbbltta :: Ptr Tensor
-> Ptr TensorList
-> Int64
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Int64
-> CBool
-> CDouble
-> CBool
-> CBool
-> Ptr IntArray
-> Ptr Tensor
-> Ptr Tensor
-> Ptr (StdArray '(CBool, 4))
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, TensorList)))
miopen_rnn_backward_tlltttttttlllbdbbltta Ptr Tensor
_input Ptr TensorList
_weight Int64
_weight_stride0 Ptr Tensor
_weight_buf Ptr Tensor
_hx Ptr Tensor
_cx Ptr Tensor
_output Ptr Tensor
_grad_output Ptr Tensor
_grad_hy Ptr Tensor
_grad_cy Int64
_mode Int64
_hidden_size Int64
_num_layers CBool
_batch_first CDouble
_dropout CBool
_train CBool
_bidirectional Ptr IntArray
_batch_sizes Ptr Tensor
_dropout_state Ptr Tensor
_reserve Ptr (StdArray '(CBool, 4))
_output_mask =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,std::vector<at::Tensor>>(at::miopen_rnn_backward(
    *$(at::Tensor* _input)
  , *$(std::vector<at::Tensor>* _weight)
  , $(int64_t _weight_stride0)
  , *$(at::Tensor* _weight_buf)
  , *$(at::Tensor* _hx)
  , *$(at::Tensor* _cx)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _grad_hy)
  , *$(at::Tensor* _grad_cy)
  , $(int64_t _mode)
  , $(int64_t _hidden_size)
  , $(int64_t _num_layers)
  , $(bool _batch_first)
  , $(double _dropout)
  , $(bool _train)
  , $(bool _bidirectional)
  , *$(std::vector<int64_t>* _batch_sizes)
  , *$(at::Tensor* _dropout_state)
  , *$(at::Tensor* _reserve)
  , *$(std::array<bool,4>* _output_mask)));
  }|]

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

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

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

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

_sparse_mask_helper_tt
  :: Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_sparse_mask_helper_tt :: Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_sparse_mask_helper_tt Ptr Tensor
_t Ptr Tensor
_mask_indices =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_mask_helper(
    *$(at::Tensor* _t)
  , *$(at::Tensor* _mask_indices)));
  }|]

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

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

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

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

mode_out_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
mode_out_tttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
mode_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::mode_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)));
  }|]

mode_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
mode_out_ttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
mode_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::mode_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)));
  }|]

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

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

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

mode_out_tttn
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Dimname
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
mode_out_tttn :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Dimname
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
mode_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::mode_out(
    *$(at::Tensor* _values)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _self)
  , *$(at::Dimname* _dim)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

native_batch_norm_tttttbdd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CDouble
  -> CDouble
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
native_batch_norm_tttttbdd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CDouble
-> CDouble
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
native_batch_norm_tttttbdd Ptr Tensor
_input Ptr Tensor
_weight Ptr Tensor
_bias Ptr Tensor
_running_mean Ptr Tensor
_running_var CBool
_training CDouble
_momentum CDouble
_eps =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_batch_norm(
    *$(at::Tensor* _input)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(at::Tensor* _running_mean)
  , *$(at::Tensor* _running_var)
  , $(bool _training)
  , $(double _momentum)
  , $(double _eps)));
  }|]

native_batch_norm_out_ttttttttbdd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CDouble
  -> CDouble
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
native_batch_norm_out_ttttttttbdd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CDouble
-> CDouble
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
native_batch_norm_out_ttttttttbdd Ptr Tensor
_out Ptr Tensor
_save_mean Ptr Tensor
_save_invstd Ptr Tensor
_input Ptr Tensor
_weight Ptr Tensor
_bias Ptr Tensor
_running_mean Ptr Tensor
_running_var CBool
_training CDouble
_momentum CDouble
_eps =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_batch_norm_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _save_mean)
  , *$(at::Tensor* _save_invstd)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(at::Tensor* _running_mean)
  , *$(at::Tensor* _running_var)
  , $(bool _training)
  , $(double _momentum)
  , $(double _eps)));
  }|]

batch_norm_stats_td
  :: Ptr Tensor
  -> CDouble
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
batch_norm_stats_td :: Ptr Tensor -> CDouble -> IO (Ptr (StdTuple '(Tensor, Tensor)))
batch_norm_stats_td Ptr Tensor
_input CDouble
_eps =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_stats(
    *$(at::Tensor* _input)
  , $(double _eps)));
  }|]

batch_norm_elemt_tttttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr Tensor)
batch_norm_elemt_tttttd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> IO (Ptr Tensor)
batch_norm_elemt_tttttd Ptr Tensor
_input Ptr Tensor
_weight Ptr Tensor
_bias Ptr Tensor
_mean Ptr Tensor
_invstd CDouble
_eps =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::batch_norm_elemt(
    *$(at::Tensor* _input)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(at::Tensor* _mean)
  , *$(at::Tensor* _invstd)
  , $(double _eps)));
  }|]