-- generated by using spec/Declarations.yaml

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

module Torch.Internal.Unmanaged.Native.Native14 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>"


miopen_convolution_out_ttttllllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr Tensor)
miopen_convolution_out_ttttllllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> CBool
-> CBool
-> IO (Ptr Tensor)
miopen_convolution_out_ttttllllbb Ptr Tensor
_out 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_out(
    *$(at::Tensor* _out)
  , *$(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_out_ttttlllllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr Tensor)
miopen_convolution_transpose_out_ttttlllllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> CBool
-> CBool
-> IO (Ptr Tensor)
miopen_convolution_transpose_out_ttttlllllbb Ptr Tensor
_out 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_out(
    *$(at::Tensor* _out)
  , *$(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_out_ttttllllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr Tensor)
miopen_depthwise_convolution_out_ttttllllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> CBool
-> CBool
-> IO (Ptr Tensor)
miopen_depthwise_convolution_out_ttttllllbb Ptr Tensor
_out 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_out(
    *$(at::Tensor* _out)
  , *$(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_out_ttttttllttlllbdbblt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> 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_out_ttttttllttlllbdbblt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> 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_out_ttttttllttlllbdbblt Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_out3 Ptr Tensor
_out4 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_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _out3)
  , *$(at::Tensor* _out4)
  , *$(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_out_tttltlltttttttlllbdbbltta
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr TensorList
  -> 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 (())
miopen_rnn_backward_out_tttltlltttttttlllbdbbltta :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr TensorList
-> 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 ()
miopen_rnn_backward_out_tttltlltttttttlllbdbbltta Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr TensorList
_out3 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| void {  (at::miopen_rnn_backward_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(std::vector<at::Tensor>* _out3)
  , *$(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)));
  }|]

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

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

_native_batch_norm_legit_functional_tttttbdd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CDouble
  -> CDouble
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
_native_batch_norm_legit_functional_tttttbdd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CDouble
-> CDouble
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor, Tensor)))
_native_batch_norm_legit_functional_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,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::_native_batch_norm_legit_functional(
    *$(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_out_tttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
batch_norm_stats_out_tttd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
batch_norm_stats_out_tttd Ptr Tensor
_out0 Ptr Tensor
_out1 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_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _input)
  , $(double _eps)));
  }|]

batch_norm_gather_stats_out_tttttttddl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CDouble
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
batch_norm_gather_stats_out_tttttttddl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> CDouble
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
batch_norm_gather_stats_out_tttttttddl Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_input Ptr Tensor
_mean Ptr Tensor
_invstd Ptr Tensor
_running_mean Ptr Tensor
_running_var CDouble
_momentum CDouble
_eps Int64
_count =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_gather_stats_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _mean)
  , *$(at::Tensor* _invstd)
  , *$(at::Tensor* _running_mean)
  , *$(at::Tensor* _running_var)
  , $(double _momentum)
  , $(double _eps)
  , $(int64_t _count)));
  }|]

batch_norm_gather_stats_with_counts_out_tttttttddt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> CDouble
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
batch_norm_gather_stats_with_counts_out_tttttttddt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> CDouble
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
batch_norm_gather_stats_with_counts_out_tttttttddt Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_input Ptr Tensor
_mean Ptr Tensor
_invstd Ptr Tensor
_running_mean Ptr Tensor
_running_var CDouble
_momentum CDouble
_eps Ptr Tensor
_counts =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_gather_stats_with_counts_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _mean)
  , *$(at::Tensor* _invstd)
  , *$(at::Tensor* _running_mean)
  , *$(at::Tensor* _running_var)
  , $(double _momentum)
  , $(double _eps)
  , *$(at::Tensor* _counts)));
  }|]

native_batch_norm_backward_out_ttttttttttbda
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CDouble
  -> Ptr (StdArray '(CBool,3))
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
native_batch_norm_backward_out_ttttttttttbda :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CDouble
-> Ptr (StdArray '(CBool, 3))
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
native_batch_norm_backward_out_ttttttttttbda Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_grad_out Ptr Tensor
_input Ptr Tensor
_weight Ptr Tensor
_running_mean Ptr Tensor
_running_var Ptr Tensor
_save_mean Ptr Tensor
_save_invstd CBool
_train CDouble
_eps Ptr (StdArray '(CBool, 3))
_output_mask =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::native_batch_norm_backward_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _grad_out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _running_mean)
  , *$(at::Tensor* _running_var)
  , *$(at::Tensor* _save_mean)
  , *$(at::Tensor* _save_invstd)
  , $(bool _train)
  , $(double _eps)
  , *$(std::array<bool,3>* _output_mask)));
  }|]

batch_norm_backward_reduce_out_tttttttttbbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor)))
batch_norm_backward_reduce_out_tttttttttbbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor)))
batch_norm_backward_reduce_out_tttttttttbbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_out3 Ptr Tensor
_grad_out Ptr Tensor
_input Ptr Tensor
_mean Ptr Tensor
_invstd Ptr Tensor
_weight CBool
_input_g CBool
_weight_g CBool
_bias_g =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor>(at::batch_norm_backward_reduce_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _out3)
  , *$(at::Tensor* _grad_out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _mean)
  , *$(at::Tensor* _invstd)
  , *$(at::Tensor* _weight)
  , $(bool _input_g)
  , $(bool _weight_g)
  , $(bool _bias_g)));
  }|]

batch_norm_backward_elemt_out_ttttttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
batch_norm_backward_elemt_out_ttttttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr Tensor)
batch_norm_backward_elemt_out_ttttttttt Ptr Tensor
_out Ptr Tensor
_grad_out Ptr Tensor
_input Ptr Tensor
_mean Ptr Tensor
_invstd Ptr Tensor
_weight Ptr Tensor
_mean_dy Ptr Tensor
_mean_dy_xmu Ptr Tensor
_count =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::batch_norm_backward_elemt_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _grad_out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _mean)
  , *$(at::Tensor* _invstd)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _mean_dy)
  , *$(at::Tensor* _mean_dy_xmu)
  , *$(at::Tensor* _count)));
  }|]

batch_norm_update_stats_out_tttttd
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
batch_norm_update_stats_out_tttttd :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
batch_norm_update_stats_out_tttttd Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_input Ptr Tensor
_running_mean Ptr Tensor
_running_var CDouble
_momentum =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::batch_norm_update_stats_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _running_mean)
  , *$(at::Tensor* _running_var)
  , $(double _momentum)));
  }|]

_nnpack_spatial_convolution_out_ttttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_nnpack_spatial_convolution_out_ttttll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
_nnpack_spatial_convolution_out_ttttll Ptr Tensor
_out Ptr Tensor
_input Ptr Tensor
_weight Ptr Tensor
_bias Ptr IntArray
_padding Ptr IntArray
_stride =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nnpack_spatial_convolution_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(std::vector<int64_t>* _padding)
  , *$(std::vector<int64_t>* _stride)));
  }|]

_nnpack_spatial_convolution_out_ttttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_nnpack_spatial_convolution_out_ttttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> IO (Ptr Tensor)
_nnpack_spatial_convolution_out_ttttl Ptr Tensor
_out Ptr Tensor
_input Ptr Tensor
_weight Ptr Tensor
_bias Ptr IntArray
_padding =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nnpack_spatial_convolution_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _weight)
  , *$(at::Tensor* _bias)
  , *$(std::vector<int64_t>* _padding)));
  }|]

ones_out_tlN
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
ones_out_tlN :: Ptr Tensor -> Ptr IntArray -> Ptr DimnameList -> IO (Ptr Tensor)
ones_out_tlN Ptr Tensor
_out Ptr IntArray
_size Ptr DimnameList
_names =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::ones_out(
    *$(at::Tensor* _out)
  , *$(std::vector<int64_t>* _size)
  , *$(std::vector<at::Dimname>* _names)));
  }|]

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

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

_euclidean_dist_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_euclidean_dist_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_euclidean_dist_out_ttt Ptr Tensor
_out Ptr Tensor
_x1 Ptr Tensor
_x2 =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_euclidean_dist_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x1)
  , *$(at::Tensor* _x2)));
  }|]

_cdist_forward_out_tttdl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> IO (Ptr Tensor)
_cdist_forward_out_tttdl :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> CDouble -> Int64 -> IO (Ptr Tensor)
_cdist_forward_out_tttdl Ptr Tensor
_out Ptr Tensor
_x1 Ptr Tensor
_x2 CDouble
_p Int64
_compute_mode =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cdist_forward_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _x1)
  , *$(at::Tensor* _x2)
  , $(double _p)
  , $(int64_t _compute_mode)));
  }|]

_cdist_backward_out_ttttdt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_cdist_backward_out_ttttdt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Ptr Tensor
-> IO (Ptr Tensor)
_cdist_backward_out_ttttdt Ptr Tensor
_out Ptr Tensor
_grad Ptr Tensor
_x1 Ptr Tensor
_x2 CDouble
_p Ptr Tensor
_cdist =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_cdist_backward_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _grad)
  , *$(at::Tensor* _x1)
  , *$(at::Tensor* _x2)
  , $(double _p)
  , *$(at::Tensor* _cdist)));
  }|]

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

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

_pdist_backward_out_tttdt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_pdist_backward_out_tttdt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Ptr Tensor
-> IO (Ptr Tensor)
_pdist_backward_out_tttdt Ptr Tensor
_out Ptr Tensor
_grad Ptr Tensor
_self CDouble
_p Ptr Tensor
_pdist =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_pdist_backward_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _grad)
  , *$(at::Tensor* _self)
  , $(double _p)
  , *$(at::Tensor* _pdist)));
  }|]

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

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

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

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

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

scalar_tensor_out_ts
  :: Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
scalar_tensor_out_ts :: Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
scalar_tensor_out_ts Ptr Tensor
_out Ptr Scalar
_s =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::scalar_tensor_out(
    *$(at::Tensor* _out)
  , *$(at::Scalar* _s)));
  }|]

rand_out_tlN
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
rand_out_tlN :: Ptr Tensor -> Ptr IntArray -> Ptr DimnameList -> IO (Ptr Tensor)
rand_out_tlN Ptr Tensor
_out Ptr IntArray
_size Ptr DimnameList
_names =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_out(
    *$(at::Tensor* _out)
  , *$(std::vector<int64_t>* _size)
  , *$(std::vector<at::Dimname>* _names)));
  }|]

rand_out_tlGN
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr Generator
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
rand_out_tlGN :: Ptr Tensor
-> Ptr IntArray
-> Ptr Generator
-> Ptr DimnameList
-> IO (Ptr Tensor)
rand_out_tlGN Ptr Tensor
_out Ptr IntArray
_size Ptr Generator
_generator Ptr DimnameList
_names =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::rand_out(
    *$(at::Tensor* _out)
  , *$(std::vector<int64_t>* _size)
  , *$(at::Generator* _generator)
  , *$(std::vector<at::Dimname>* _names)));
  }|]

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

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

randint_like_out_ttlM
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> MemoryFormat
  -> IO (Ptr Tensor)
randint_like_out_ttlM :: Ptr Tensor
-> Ptr Tensor -> Int64 -> MemoryFormat -> IO (Ptr Tensor)
randint_like_out_ttlM Ptr Tensor
_out Ptr Tensor
_self Int64
_high MemoryFormat
_memory_format =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _high)
  , $(at::MemoryFormat _memory_format)));
  }|]

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

randint_like_out_ttllM
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> MemoryFormat
  -> IO (Ptr Tensor)
randint_like_out_ttllM :: Ptr Tensor
-> Ptr Tensor -> Int64 -> Int64 -> MemoryFormat -> IO (Ptr Tensor)
randint_like_out_ttllM Ptr Tensor
_out Ptr Tensor
_self Int64
_low Int64
_high MemoryFormat
_memory_format =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randint_like_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _low)
  , $(int64_t _high)
  , $(at::MemoryFormat _memory_format)));
  }|]

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

randn_out_tlN
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
randn_out_tlN :: Ptr Tensor -> Ptr IntArray -> Ptr DimnameList -> IO (Ptr Tensor)
randn_out_tlN Ptr Tensor
_out Ptr IntArray
_size Ptr DimnameList
_names =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_out(
    *$(at::Tensor* _out)
  , *$(std::vector<int64_t>* _size)
  , *$(std::vector<at::Dimname>* _names)));
  }|]

randn_out_tlGN
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr Generator
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
randn_out_tlGN :: Ptr Tensor
-> Ptr IntArray
-> Ptr Generator
-> Ptr DimnameList
-> IO (Ptr Tensor)
randn_out_tlGN Ptr Tensor
_out Ptr IntArray
_size Ptr Generator
_generator Ptr DimnameList
_names =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::randn_out(
    *$(at::Tensor* _out)
  , *$(std::vector<int64_t>* _size)
  , *$(at::Generator* _generator)
  , *$(std::vector<at::Dimname>* _names)));
  }|]

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

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

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

repeat_interleave_out_ttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
repeat_interleave_out_ttl :: Ptr Tensor -> Ptr Tensor -> Int64 -> IO (Ptr Tensor)
repeat_interleave_out_ttl Ptr Tensor
_out Ptr Tensor
_repeats Int64
_output_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::repeat_interleave_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _repeats)
  , $(int64_t _output_size)));
  }|]

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

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

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

select_backward_out_ttlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
select_backward_out_ttlll :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> Int64 -> Int64 -> IO (Ptr Tensor)
select_backward_out_ttlll Ptr Tensor
_out Ptr Tensor
_grad_output Ptr IntArray
_input_sizes Int64
_dim Int64
_index =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::select_backward_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _grad_output)
  , *$(std::vector<int64_t>* _input_sizes)
  , $(int64_t _dim)
  , $(int64_t _index)));
  }|]

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

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

slice_backward_out_ttlllll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
slice_backward_out_ttlllll :: Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Int64
-> Int64
-> Int64
-> Int64
-> IO (Ptr Tensor)
slice_backward_out_ttlllll Ptr Tensor
_out Ptr Tensor
_grad_output Ptr IntArray
_input_sizes Int64
_dim Int64
_start Int64
_end Int64
_step =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::slice_backward_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _grad_output)
  , *$(std::vector<int64_t>* _input_sizes)
  , $(int64_t _dim)
  , $(int64_t _start)
  , $(int64_t _end)
  , $(int64_t _step)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std_mean_out_tttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
std_mean_out_tttll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
std_mean_out_tttll Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self Ptr IntArray
_dim Int64
_correction =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::std_mean_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(int64_t _correction)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

_transform_bias_rescale_qkv_out_tttttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_transform_bias_rescale_qkv_out_tttttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_transform_bias_rescale_qkv_out_tttttl Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_qkv Ptr Tensor
_qkv_bias Int64
_num_heads =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_transform_bias_rescale_qkv_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _qkv)
  , *$(at::Tensor* _qkv_bias)
  , $(int64_t _num_heads)));
  }|]

_nested_tensor_from_mask_out_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
_nested_tensor_from_mask_out_tttb :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
_nested_tensor_from_mask_out_tttb Ptr Tensor
_out Ptr Tensor
_t Ptr Tensor
_mask CBool
_mask_check =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_mask_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _t)
  , *$(at::Tensor* _mask)
  , $(bool _mask_check)));
  }|]

_nested_tensor_from_mask_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_nested_tensor_from_mask_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_nested_tensor_from_mask_out_ttt Ptr Tensor
_out Ptr Tensor
_t Ptr Tensor
_mask =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_tensor_from_mask_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _t)
  , *$(at::Tensor* _mask)));
  }|]

_nested_from_padded_out_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
_nested_from_padded_out_tttb :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
_nested_from_padded_out_tttb Ptr Tensor
_out Ptr Tensor
_padded Ptr Tensor
_cpu_nested_shape_example CBool
_fuse_transform_0213 =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _padded)
  , *$(at::Tensor* _cpu_nested_shape_example)
  , $(bool _fuse_transform_0213)));
  }|]

_nested_from_padded_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_nested_from_padded_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_nested_from_padded_out_ttt Ptr Tensor
_out Ptr Tensor
_padded Ptr Tensor
_cpu_nested_shape_example =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _padded)
  , *$(at::Tensor* _cpu_nested_shape_example)));
  }|]

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

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

_nested_from_padded_and_nested_example_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_nested_from_padded_and_nested_example_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_nested_from_padded_and_nested_example_out_ttt Ptr Tensor
_out Ptr Tensor
_padded Ptr Tensor
_nt_example =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_nested_from_padded_and_nested_example_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _padded)
  , *$(at::Tensor* _nt_example)));
  }|]

_trilinear_out_ttttlllll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Int64
  -> IO (Ptr Tensor)
_trilinear_out_ttttlllll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Int64
-> IO (Ptr Tensor)
_trilinear_out_ttttlllll Ptr Tensor
_out Ptr Tensor
_i1 Ptr Tensor
_i2 Ptr Tensor
_i3 Ptr IntArray
_expand1 Ptr IntArray
_expand2 Ptr IntArray
_expand3 Ptr IntArray
_sumdim Int64
_unroll_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_trilinear_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _i1)
  , *$(at::Tensor* _i2)
  , *$(at::Tensor* _i3)
  , *$(std::vector<int64_t>* _expand1)
  , *$(std::vector<int64_t>* _expand2)
  , *$(std::vector<int64_t>* _expand3)
  , *$(std::vector<int64_t>* _sumdim)
  , $(int64_t _unroll_dim)));
  }|]

_trilinear_out_ttttllll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_trilinear_out_ttttllll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> Ptr IntArray
-> IO (Ptr Tensor)
_trilinear_out_ttttllll Ptr Tensor
_out Ptr Tensor
_i1 Ptr Tensor
_i2 Ptr Tensor
_i3 Ptr IntArray
_expand1 Ptr IntArray
_expand2 Ptr IntArray
_expand3 Ptr IntArray
_sumdim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_trilinear_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _i1)
  , *$(at::Tensor* _i2)
  , *$(at::Tensor* _i3)
  , *$(std::vector<int64_t>* _expand1)
  , *$(std::vector<int64_t>* _expand2)
  , *$(std::vector<int64_t>* _expand3)
  , *$(std::vector<int64_t>* _sumdim)));
  }|]

_unique_out_tttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_unique_out_tttbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_unique_out_tttbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self CBool
_sorted CBool
_return_inverse =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_unique_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , $(bool _sorted)
  , $(bool _return_inverse)));
  }|]

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

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

unique_dim_out_ttttlbbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
unique_dim_out_ttttlbbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_out_ttttlbbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self Int64
_dim CBool
_sorted CBool
_return_inverse CBool
_return_counts =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(bool _sorted)
  , $(bool _return_inverse)
  , $(bool _return_counts)));
  }|]

unique_dim_out_ttttlbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
unique_dim_out_ttttlbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_out_ttttlbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self Int64
_dim CBool
_sorted CBool
_return_inverse =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(bool _sorted)
  , $(bool _return_inverse)));
  }|]

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

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

unique_consecutive_out_ttttbbl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
unique_consecutive_out_ttttbbl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_consecutive_out_ttttbbl Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self CBool
_return_inverse CBool
_return_counts Int64
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(bool _return_inverse)
  , $(bool _return_counts)
  , $(int64_t _dim)));
  }|]

unique_consecutive_out_ttttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
unique_consecutive_out_ttttbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_consecutive_out_ttttbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self CBool
_return_inverse CBool
_return_counts =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(bool _return_inverse)
  , $(bool _return_counts)));
  }|]

unique_consecutive_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
unique_consecutive_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_consecutive_out_ttttb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self CBool
_return_inverse =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_consecutive_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(bool _return_inverse)));
  }|]

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

unique_dim_consecutive_out_ttttlbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
unique_dim_consecutive_out_ttttlbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_consecutive_out_ttttlbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self Int64
_dim CBool
_return_inverse CBool
_return_counts =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_consecutive_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(bool _return_inverse)
  , $(bool _return_counts)));
  }|]

unique_dim_consecutive_out_ttttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
unique_dim_consecutive_out_ttttlb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
unique_dim_consecutive_out_ttttlb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self Int64
_dim CBool
_return_inverse =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::unique_dim_consecutive_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(bool _return_inverse)));
  }|]

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

_unique2_out_ttttbbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_unique2_out_ttttbbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_unique2_out_ttttbbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self CBool
_sorted CBool
_return_inverse CBool
_return_counts =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(bool _sorted)
  , $(bool _return_inverse)
  , $(bool _return_counts)));
  }|]

_unique2_out_ttttbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_unique2_out_ttttbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_unique2_out_ttttbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self CBool
_sorted CBool
_return_inverse =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(bool _sorted)
  , $(bool _return_inverse)));
  }|]

_unique2_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_unique2_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_unique2_out_ttttb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_self CBool
_sorted =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_unique2_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _self)
  , $(bool _sorted)));
  }|]

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

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

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

var_mean_out_tttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
var_mean_out_tttll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
var_mean_out_tttll Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self Ptr IntArray
_dim Int64
_correction =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::var_mean_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _dim)
  , $(int64_t _correction)));
  }|]

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

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

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

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

_weight_norm_interface_backward_out_ttttttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_weight_norm_interface_backward_out_ttttttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_weight_norm_interface_backward_out_ttttttl Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_grad_w Ptr Tensor
_saved_v Ptr Tensor
_saved_g Ptr Tensor
_saved_norms Int64
_dim =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_weight_norm_interface_backward_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _grad_w)
  , *$(at::Tensor* _saved_v)
  , *$(at::Tensor* _saved_g)
  , *$(at::Tensor* _saved_norms)
  , $(int64_t _dim)));
  }|]

zeros_out_tlN
  :: Ptr Tensor
  -> Ptr IntArray
  -> Ptr DimnameList
  -> IO (Ptr Tensor)
zeros_out_tlN :: Ptr Tensor -> Ptr IntArray -> Ptr DimnameList -> IO (Ptr Tensor)
zeros_out_tlN Ptr Tensor
_out Ptr IntArray
_size Ptr DimnameList
_names =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::zeros_out(
    *$(at::Tensor* _out)
  , *$(std::vector<int64_t>* _size)
  , *$(std::vector<at::Dimname>* _names)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

binomial_out_tttG
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Generator
  -> IO (Ptr Tensor)
binomial_out_tttG :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Generator -> IO (Ptr Tensor)
binomial_out_tttG Ptr Tensor
_out Ptr Tensor
_count Ptr Tensor
_prob Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binomial_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _count)
  , *$(at::Tensor* _prob)
  , *$(at::Generator* _generator)));
  }|]

binomial_out_ttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
binomial_out_ttt :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
binomial_out_ttt Ptr Tensor
_out Ptr Tensor
_count Ptr Tensor
_prob =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::binomial_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _count)
  , *$(at::Tensor* _prob)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

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

_sparse_log_softmax_out_ttlb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> CBool
  -> IO (Ptr Tensor)
_sparse_log_softmax_out_ttlb :: Ptr Tensor -> Ptr Tensor -> Int64 -> CBool -> IO (Ptr Tensor)
_sparse_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::_sparse_log_softmax_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _dim)
  , $(bool _half_to_float)));
  }|]

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

_spdiags_out_tttlL
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Layout
  -> IO (Ptr Tensor)
_spdiags_out_tttlL :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr IntArray
-> MemoryFormat
-> IO (Ptr Tensor)
_spdiags_out_tttlL Ptr Tensor
_out Ptr Tensor
_diagonals Ptr Tensor
_offsets Ptr IntArray
_shape MemoryFormat
_layout =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_spdiags_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _diagonals)
  , *$(at::Tensor* _offsets)
  , *$(std::vector<int64_t>* _shape)
  , $(at::Layout _layout)));
  }|]

_spdiags_out_tttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_spdiags_out_tttl :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr IntArray -> IO (Ptr Tensor)
_spdiags_out_tttl Ptr Tensor
_out Ptr Tensor
_diagonals Ptr Tensor
_offsets Ptr IntArray
_shape =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_spdiags_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _diagonals)
  , *$(at::Tensor* _offsets)
  , *$(std::vector<int64_t>* _shape)));
  }|]

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

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

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

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

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

resize_as_out_tttM
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> MemoryFormat
  -> IO (Ptr Tensor)
resize_as_out_tttM :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> MemoryFormat -> IO (Ptr Tensor)
resize_as_out_tttM Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_the_template MemoryFormat
_memory_format =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _the_template)
  , $(at::MemoryFormat _memory_format)));
  }|]

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

resize_as_ttM
  :: Ptr Tensor
  -> Ptr Tensor
  -> MemoryFormat
  -> IO (Ptr Tensor)
resize_as_ttM :: Ptr Tensor -> Ptr Tensor -> MemoryFormat -> IO (Ptr Tensor)
resize_as_ttM Ptr Tensor
_self Ptr Tensor
_the_template MemoryFormat
_memory_format =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::resize_as(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _the_template)
  , $(at::MemoryFormat _memory_format)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

_sparse_addmm_out_ttttss
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> Ptr Scalar
  -> IO (Ptr Tensor)
_sparse_addmm_out_ttttss :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> Ptr Scalar
-> IO (Ptr Tensor)
_sparse_addmm_out_ttttss Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_beta Ptr Scalar
_alpha =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _mat1)
  , *$(at::Tensor* _mat2)
  , *$(at::Scalar* _beta)
  , *$(at::Scalar* _alpha)));
  }|]

_sparse_addmm_out_tttts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
_sparse_addmm_out_tttts :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Scalar
-> IO (Ptr Tensor)
_sparse_addmm_out_tttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mat1 Ptr Tensor
_mat2 Ptr Scalar
_beta =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_addmm_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _mat1)
  , *$(at::Tensor* _mat2)
  , *$(at::Scalar* _beta)));
  }|]

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

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

_sparse_coo_tensor_with_dims_out_tlll
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr IntArray
  -> IO (Ptr Tensor)
_sparse_coo_tensor_with_dims_out_tlll :: Ptr Tensor -> Int64 -> Int64 -> Ptr IntArray -> IO (Ptr Tensor)
_sparse_coo_tensor_with_dims_out_tlll Ptr Tensor
_out Int64
_sparse_dim Int64
_dense_dim Ptr IntArray
_size =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_coo_tensor_with_dims_out(
    *$(at::Tensor* _out)
  , $(int64_t _sparse_dim)
  , $(int64_t _dense_dim)
  , *$(std::vector<int64_t>* _size)));
  }|]

_sparse_coo_tensor_with_dims_and_tensors_out_tllltt
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr IntArray
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_sparse_coo_tensor_with_dims_and_tensors_out_tllltt :: Ptr Tensor
-> Int64
-> Int64
-> Ptr IntArray
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr Tensor)
_sparse_coo_tensor_with_dims_and_tensors_out_tllltt Ptr Tensor
_out Int64
_sparse_dim Int64
_dense_dim Ptr IntArray
_size Ptr Tensor
_indices Ptr Tensor
_values =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_sparse_coo_tensor_with_dims_and_tensors_out(
    *$(at::Tensor* _out)
  , $(int64_t _sparse_dim)
  , $(int64_t _dense_dim)
  , *$(std::vector<int64_t>* _size)
  , *$(at::Tensor* _indices)
  , *$(at::Tensor* _values)));
  }|]

sparse_resize_out_ttlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
sparse_resize_out_ttlll :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> Int64 -> Int64 -> IO (Ptr Tensor)
sparse_resize_out_ttlll Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_size Int64
_sparse_dim Int64
_dense_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_resize_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)
  , $(int64_t _sparse_dim)
  , $(int64_t _dense_dim)));
  }|]

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

sparse_resize_and_clear_out_ttlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr IntArray
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
sparse_resize_and_clear_out_ttlll :: Ptr Tensor
-> Ptr Tensor -> Ptr IntArray -> Int64 -> Int64 -> IO (Ptr Tensor)
sparse_resize_and_clear_out_ttlll Ptr Tensor
_out Ptr Tensor
_self Ptr IntArray
_size Int64
_sparse_dim Int64
_dense_dim =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::sparse_resize_and_clear_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(std::vector<int64_t>* _size)
  , $(int64_t _sparse_dim)
  , $(int64_t _dense_dim)));
  }|]

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

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

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

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

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

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

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

copy_sparse_to_sparse_out_tttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
copy_sparse_to_sparse_out_tttb :: Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
copy_sparse_to_sparse_out_tttb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_src CBool
_non_blocking =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_sparse_to_sparse_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _src)
  , $(bool _non_blocking)));
  }|]

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

copy_sparse_to_sparse_ttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
copy_sparse_to_sparse_ttb :: Ptr Tensor -> Ptr Tensor -> CBool -> IO (Ptr Tensor)
copy_sparse_to_sparse_ttb Ptr Tensor
_self Ptr Tensor
_src CBool
_non_blocking =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::copy_sparse_to_sparse(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _src)
  , $(bool _non_blocking)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

quantize_per_tensor_dynamic_out_ttsb
  :: Ptr Tensor
  -> Ptr Tensor
  -> ScalarType
  -> CBool
  -> IO (Ptr Tensor)
quantize_per_tensor_dynamic_out_ttsb :: Ptr Tensor
-> Ptr Tensor -> MemoryFormat -> CBool -> IO (Ptr Tensor)
quantize_per_tensor_dynamic_out_ttsb Ptr Tensor
_out Ptr Tensor
_self MemoryFormat
_dtype CBool
_reduce_range =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor_dynamic_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(at::ScalarType _dtype)
  , $(bool _reduce_range)));
  }|]

quantize_per_tensor_out_ttdls
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> ScalarType
  -> IO (Ptr Tensor)
quantize_per_tensor_out_ttdls :: Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> MemoryFormat
-> IO (Ptr Tensor)
quantize_per_tensor_out_ttdls Ptr Tensor
_out Ptr Tensor
_self CDouble
_scale Int64
_zero_point MemoryFormat
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _scale)
  , $(int64_t _zero_point)
  , $(at::ScalarType _dtype)));
  }|]

quantize_per_tensor_out_tttts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> ScalarType
  -> IO (Ptr Tensor)
quantize_per_tensor_out_tttts :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> MemoryFormat
-> IO (Ptr Tensor)
quantize_per_tensor_out_tttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_scale Ptr Tensor
_zero_point MemoryFormat
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_tensor_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(at::ScalarType _dtype)));
  }|]

quantize_per_tensor_out_lltts
  :: Ptr TensorList
  -> Ptr TensorList
  -> Ptr Tensor
  -> Ptr Tensor
  -> ScalarType
  -> IO (())
quantize_per_tensor_out_lltts :: Ptr TensorList
-> Ptr TensorList
-> Ptr Tensor
-> Ptr Tensor
-> MemoryFormat
-> IO ()
quantize_per_tensor_out_lltts Ptr TensorList
_out Ptr TensorList
_tensors Ptr Tensor
_scales Ptr Tensor
_zero_points MemoryFormat
_dtype =
  [C.throwBlock| void {  (at::quantize_per_tensor_out(
    *$(std::vector<at::Tensor>* _out)
  , *$(std::vector<at::Tensor>* _tensors)
  , *$(at::Tensor* _scales)
  , *$(at::Tensor* _zero_points)
  , $(at::ScalarType _dtype)));
  }|]

quantize_per_channel_out_ttttls
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> ScalarType
  -> IO (Ptr Tensor)
quantize_per_channel_out_ttttls :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> MemoryFormat
-> IO (Ptr Tensor)
quantize_per_channel_out_ttttls Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_scales Ptr Tensor
_zero_points Int64
_axis MemoryFormat
_dtype =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::quantize_per_channel_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scales)
  , *$(at::Tensor* _zero_points)
  , $(int64_t _axis)
  , $(at::ScalarType _dtype)));
  }|]

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

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

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

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

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

_make_per_tensor_quantized_tensor_out_ttdl
  :: Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> IO (Ptr Tensor)
_make_per_tensor_quantized_tensor_out_ttdl :: Ptr Tensor -> Ptr Tensor -> CDouble -> Int64 -> IO (Ptr Tensor)
_make_per_tensor_quantized_tensor_out_ttdl Ptr Tensor
_out Ptr Tensor
_self CDouble
_scale Int64
_zero_point =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_per_tensor_quantized_tensor_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(double _scale)
  , $(int64_t _zero_point)));
  }|]

_make_per_channel_quantized_tensor_out_ttttl
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> IO (Ptr Tensor)
_make_per_channel_quantized_tensor_out_ttttl :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> IO (Ptr Tensor)
_make_per_channel_quantized_tensor_out_ttttl Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_scale Ptr Tensor
_zero_point Int64
_axis =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_make_per_channel_quantized_tensor_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(int64_t _axis)));
  }|]

fake_quantize_per_tensor_affine_cachemask_out_tttdlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
fake_quantize_per_tensor_affine_cachemask_out_tttdlll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
fake_quantize_per_tensor_affine_cachemask_out_tttdlll Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self CDouble
_scale Int64
_zero_point Int64
_quant_min Int64
_quant_max =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fake_quantize_per_tensor_affine_cachemask_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , $(double _scale)
  , $(int64_t _zero_point)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)));
  }|]

_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out_ttttttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out_ttttttll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out_ttttttll Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self Ptr Tensor
_scale Ptr Tensor
_zero_point Ptr Tensor
_fake_quant_enabled Int64
_quant_min Int64
_quant_max =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , *$(at::Tensor* _fake_quant_enabled)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)));
  }|]

_fake_quantize_learnable_per_tensor_affine_out_ttttlld
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> CDouble
  -> IO (Ptr Tensor)
_fake_quantize_learnable_per_tensor_affine_out_ttttlld :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> CDouble
-> IO (Ptr Tensor)
_fake_quantize_learnable_per_tensor_affine_out_ttttlld Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_scale Ptr Tensor
_zero_point Int64
_quant_min Int64
_quant_max CDouble
_grad_factor =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_tensor_affine_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)
  , $(double _grad_factor)));
  }|]

_fake_quantize_learnable_per_tensor_affine_out_ttttll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
_fake_quantize_learnable_per_tensor_affine_out_ttttll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> IO (Ptr Tensor)
_fake_quantize_learnable_per_tensor_affine_out_ttttll Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_scale Ptr Tensor
_zero_point Int64
_quant_min Int64
_quant_max =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_tensor_affine_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)));
  }|]

fake_quantize_per_channel_affine_cachemask_out_tttttlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
fake_quantize_per_channel_affine_cachemask_out_tttttlll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
fake_quantize_per_channel_affine_cachemask_out_tttttlll Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self Ptr Tensor
_scale Ptr Tensor
_zero_point Int64
_axis Int64
_quant_min Int64
_quant_max =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::fake_quantize_per_channel_affine_cachemask_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(int64_t _axis)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)));
  }|]

_fake_quantize_learnable_per_channel_affine_out_ttttllld
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> CDouble
  -> IO (Ptr Tensor)
_fake_quantize_learnable_per_channel_affine_out_ttttllld :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Int64
-> CDouble
-> IO (Ptr Tensor)
_fake_quantize_learnable_per_channel_affine_out_ttttllld Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_scale Ptr Tensor
_zero_point Int64
_axis Int64
_quant_min Int64
_quant_max CDouble
_grad_factor =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_channel_affine_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(int64_t _axis)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)
  , $(double _grad_factor)));
  }|]

_fake_quantize_learnable_per_channel_affine_out_ttttlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr Tensor)
_fake_quantize_learnable_per_channel_affine_out_ttttlll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Int64
-> Int64
-> Int64
-> IO (Ptr Tensor)
_fake_quantize_learnable_per_channel_affine_out_ttttlll Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_scale Ptr Tensor
_zero_point Int64
_axis Int64
_quant_min Int64
_quant_max =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_fake_quantize_learnable_per_channel_affine_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(int64_t _axis)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)));
  }|]

_fused_moving_avg_obs_fq_helper_out_tttttttttdlllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> Int64
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_fused_moving_avg_obs_fq_helper_out_tttttttttdlllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> Int64
-> Int64
-> CBool
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_fused_moving_avg_obs_fq_helper_out_tttttttttdlllbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self Ptr Tensor
_observer_on Ptr Tensor
_fake_quant_on Ptr Tensor
_running_min Ptr Tensor
_running_max Ptr Tensor
_scale Ptr Tensor
_zero_point CDouble
_averaging_const Int64
_quant_min Int64
_quant_max Int64
_ch_axis CBool
_per_row_fake_quant CBool
_symmetric_quant =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _observer_on)
  , *$(at::Tensor* _fake_quant_on)
  , *$(at::Tensor* _running_min)
  , *$(at::Tensor* _running_max)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(double _averaging_const)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)
  , $(int64_t _ch_axis)
  , $(bool _per_row_fake_quant)
  , $(bool _symmetric_quant)));
  }|]

_fused_moving_avg_obs_fq_helper_out_tttttttttdlllb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> Int64
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_fused_moving_avg_obs_fq_helper_out_tttttttttdlllb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> Int64
-> Int64
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_fused_moving_avg_obs_fq_helper_out_tttttttttdlllb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self Ptr Tensor
_observer_on Ptr Tensor
_fake_quant_on Ptr Tensor
_running_min Ptr Tensor
_running_max Ptr Tensor
_scale Ptr Tensor
_zero_point CDouble
_averaging_const Int64
_quant_min Int64
_quant_max Int64
_ch_axis CBool
_per_row_fake_quant =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _observer_on)
  , *$(at::Tensor* _fake_quant_on)
  , *$(at::Tensor* _running_min)
  , *$(at::Tensor* _running_max)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(double _averaging_const)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)
  , $(int64_t _ch_axis)
  , $(bool _per_row_fake_quant)));
  }|]

_fused_moving_avg_obs_fq_helper_out_tttttttttdlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_fused_moving_avg_obs_fq_helper_out_tttttttttdlll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> Int64
-> Int64
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_fused_moving_avg_obs_fq_helper_out_tttttttttdlll Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_self Ptr Tensor
_observer_on Ptr Tensor
_fake_quant_on Ptr Tensor
_running_min Ptr Tensor
_running_max Ptr Tensor
_scale Ptr Tensor
_zero_point CDouble
_averaging_const Int64
_quant_min Int64
_quant_max Int64
_ch_axis =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_fused_moving_avg_obs_fq_helper_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _observer_on)
  , *$(at::Tensor* _fake_quant_on)
  , *$(at::Tensor* _running_min)
  , *$(at::Tensor* _running_max)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(double _averaging_const)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)
  , $(int64_t _ch_axis)));
  }|]

_fused_moving_avg_obs_fq_helper_functional_tttttttdlllbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> Int64
  -> Int64
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
_fused_moving_avg_obs_fq_helper_functional_tttttttdlllbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> Int64
-> Int64
-> CBool
-> CBool
-> IO
     (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor, Tensor, Tensor)))
_fused_moving_avg_obs_fq_helper_functional_tttttttdlllbb Ptr Tensor
_self Ptr Tensor
_observer_on Ptr Tensor
_fake_quant_on Ptr Tensor
_running_min Ptr Tensor
_running_max Ptr Tensor
_scale Ptr Tensor
_zero_point CDouble
_averaging_const Int64
_quant_min Int64
_quant_max Int64
_ch_axis CBool
_per_row_fake_quant CBool
_symmetric_quant =
  [C.throwBlock| std::tuple<at::Tensor,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::Tensor>(at::_fused_moving_avg_obs_fq_helper_functional(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _observer_on)
  , *$(at::Tensor* _fake_quant_on)
  , *$(at::Tensor* _running_min)
  , *$(at::Tensor* _running_max)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(double _averaging_const)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)
  , $(int64_t _ch_axis)
  , $(bool _per_row_fake_quant)
  , $(bool _symmetric_quant)));
  }|]

_fused_moving_avg_obs_fq_helper_functional_tttttttdlllb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> Int64
  -> Int64
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
_fused_moving_avg_obs_fq_helper_functional_tttttttdlllb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> Int64
-> Int64
-> CBool
-> IO
     (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor, Tensor, Tensor)))
_fused_moving_avg_obs_fq_helper_functional_tttttttdlllb Ptr Tensor
_self Ptr Tensor
_observer_on Ptr Tensor
_fake_quant_on Ptr Tensor
_running_min Ptr Tensor
_running_max Ptr Tensor
_scale Ptr Tensor
_zero_point CDouble
_averaging_const Int64
_quant_min Int64
_quant_max Int64
_ch_axis CBool
_per_row_fake_quant =
  [C.throwBlock| std::tuple<at::Tensor,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::Tensor>(at::_fused_moving_avg_obs_fq_helper_functional(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _observer_on)
  , *$(at::Tensor* _fake_quant_on)
  , *$(at::Tensor* _running_min)
  , *$(at::Tensor* _running_max)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(double _averaging_const)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)
  , $(int64_t _ch_axis)
  , $(bool _per_row_fake_quant)));
  }|]

_fused_moving_avg_obs_fq_helper_functional_tttttttdlll
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CDouble
  -> Int64
  -> Int64
  -> Int64
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
_fused_moving_avg_obs_fq_helper_functional_tttttttdlll :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CDouble
-> Int64
-> Int64
-> Int64
-> IO
     (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor, Tensor, Tensor)))
_fused_moving_avg_obs_fq_helper_functional_tttttttdlll Ptr Tensor
_self Ptr Tensor
_observer_on Ptr Tensor
_fake_quant_on Ptr Tensor
_running_min Ptr Tensor
_running_max Ptr Tensor
_scale Ptr Tensor
_zero_point CDouble
_averaging_const Int64
_quant_min Int64
_quant_max Int64
_ch_axis =
  [C.throwBlock| std::tuple<at::Tensor,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::Tensor>(at::_fused_moving_avg_obs_fq_helper_functional(
    *$(at::Tensor* _self)
  , *$(at::Tensor* _observer_on)
  , *$(at::Tensor* _fake_quant_on)
  , *$(at::Tensor* _running_min)
  , *$(at::Tensor* _running_max)
  , *$(at::Tensor* _scale)
  , *$(at::Tensor* _zero_point)
  , $(double _averaging_const)
  , $(int64_t _quant_min)
  , $(int64_t _quant_max)
  , $(int64_t _ch_axis)));
  }|]

_to_copy_out_ttbM
  :: Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> MemoryFormat
  -> IO (Ptr Tensor)
_to_copy_out_ttbM :: Ptr Tensor
-> Ptr Tensor -> CBool -> MemoryFormat -> IO (Ptr Tensor)
_to_copy_out_ttbM Ptr Tensor
_out Ptr Tensor
_self CBool
_non_blocking MemoryFormat
_memory_format =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_to_copy_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(bool _non_blocking)
  , $(at::MemoryFormat _memory_format)));
  }|]

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

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

_lstm_mps_out_tttttttllbldbbb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr TensorList
  -> Ptr TensorList
  -> CBool
  -> Int64
  -> CDouble
  -> CBool
  -> CBool
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor,Tensor)))
_lstm_mps_out_tttttttllbldbbb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr TensorList
-> Ptr TensorList
-> CBool
-> Int64
-> CDouble
-> CBool
-> CBool
-> CBool
-> IO
     (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor, Tensor, Tensor)))
_lstm_mps_out_tttttttllbldbbb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_out3 Ptr Tensor
_out4 Ptr Tensor
_out5 Ptr Tensor
_input Ptr TensorList
_hx Ptr TensorList
_params CBool
_has_biases Int64
_num_layers CDouble
_dropout CBool
_train CBool
_bidirectional CBool
_batch_first =
  [C.throwBlock| std::tuple<at::Tensor,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::Tensor>(at::_lstm_mps_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _out3)
  , *$(at::Tensor* _out4)
  , *$(at::Tensor* _out5)
  , *$(at::Tensor* _input)
  , *$(std::vector<at::Tensor>* _hx)
  , *$(std::vector<at::Tensor>* _params)
  , $(bool _has_biases)
  , $(int64_t _num_layers)
  , $(double _dropout)
  , $(bool _train)
  , $(bool _bidirectional)
  , $(bool _batch_first)));
  }|]

lstm_mps_backward_out_tlltttttttllbldbbb
  :: Ptr Tensor
  -> Ptr TensorList
  -> Ptr TensorList
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr TensorList
  -> Ptr TensorList
  -> CBool
  -> Int64
  -> CDouble
  -> CBool
  -> CBool
  -> CBool
  -> IO (())
lstm_mps_backward_out_tlltttttttllbldbbb :: Ptr Tensor
-> Ptr TensorList
-> Ptr TensorList
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr TensorList
-> Ptr TensorList
-> CBool
-> Int64
-> CDouble
-> CBool
-> CBool
-> CBool
-> IO ()
lstm_mps_backward_out_tlltttttttllbldbbb Ptr Tensor
_out0 Ptr TensorList
_out1 Ptr TensorList
_out2 Ptr Tensor
_grad_y Ptr Tensor
_grad_hy Ptr Tensor
_grad_cy Ptr Tensor
_z_state Ptr Tensor
_cell_state_fwd Ptr Tensor
_input Ptr Tensor
_layersOutputs Ptr TensorList
_hx Ptr TensorList
_params CBool
_has_biases Int64
_num_layers CDouble
_dropout CBool
_train CBool
_bidirectional CBool
_batch_first =
  [C.throwBlock| void {  (at::lstm_mps_backward_out(
    *$(at::Tensor* _out0)
  , *$(std::vector<at::Tensor>* _out1)
  , *$(std::vector<at::Tensor>* _out2)
  , *$(at::Tensor* _grad_y)
  , *$(at::Tensor* _grad_hy)
  , *$(at::Tensor* _grad_cy)
  , *$(at::Tensor* _z_state)
  , *$(at::Tensor* _cell_state_fwd)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _layersOutputs)
  , *$(std::vector<at::Tensor>* _hx)
  , *$(std::vector<at::Tensor>* _params)
  , $(bool _has_biases)
  , $(int64_t _num_layers)
  , $(double _dropout)
  , $(bool _train)
  , $(bool _bidirectional)
  , $(bool _batch_first)));
  }|]

_thnn_fused_lstm_cell_out_tttttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_thnn_fused_lstm_cell_out_tttttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_thnn_fused_lstm_cell_out_tttttttt Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_input_gates Ptr Tensor
_hidden_gates Ptr Tensor
_cx Ptr Tensor
_input_bias Ptr Tensor
_hidden_bias =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _input_gates)
  , *$(at::Tensor* _hidden_gates)
  , *$(at::Tensor* _cx)
  , *$(at::Tensor* _input_bias)
  , *$(at::Tensor* _hidden_bias)));
  }|]

_thnn_fused_lstm_cell_out_ttttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_thnn_fused_lstm_cell_out_ttttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_thnn_fused_lstm_cell_out_ttttttt Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_input_gates Ptr Tensor
_hidden_gates Ptr Tensor
_cx Ptr Tensor
_input_bias =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _input_gates)
  , *$(at::Tensor* _hidden_gates)
  , *$(at::Tensor* _cx)
  , *$(at::Tensor* _input_bias)));
  }|]

_thnn_fused_lstm_cell_out_tttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_thnn_fused_lstm_cell_out_tttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_thnn_fused_lstm_cell_out_tttttt Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_input_gates Ptr Tensor
_hidden_gates Ptr Tensor
_cx =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _input_gates)
  , *$(at::Tensor* _hidden_gates)
  , *$(at::Tensor* _cx)));
  }|]

_thnn_fused_lstm_cell_backward_impl_out_ttttttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor)))
_thnn_fused_lstm_cell_backward_impl_out_ttttttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor)))
_thnn_fused_lstm_cell_backward_impl_out_ttttttttb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_grad_hy Ptr Tensor
_grad_cy Ptr Tensor
_cx Ptr Tensor
_cy Ptr Tensor
_workspace CBool
_has_bias =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor,at::Tensor>(at::_thnn_fused_lstm_cell_backward_impl_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _grad_hy)
  , *$(at::Tensor* _grad_cy)
  , *$(at::Tensor* _cx)
  , *$(at::Tensor* _cy)
  , *$(at::Tensor* _workspace)
  , $(bool _has_bias)));
  }|]

_thnn_fused_gru_cell_out_ttttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_thnn_fused_gru_cell_out_ttttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_thnn_fused_gru_cell_out_ttttttt Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_input_gates Ptr Tensor
_hidden_gates Ptr Tensor
_hx Ptr Tensor
_input_bias Ptr Tensor
_hidden_bias =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _input_gates)
  , *$(at::Tensor* _hidden_gates)
  , *$(at::Tensor* _hx)
  , *$(at::Tensor* _input_bias)
  , *$(at::Tensor* _hidden_bias)));
  }|]

_thnn_fused_gru_cell_out_tttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_thnn_fused_gru_cell_out_tttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_thnn_fused_gru_cell_out_tttttt Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_input_gates Ptr Tensor
_hidden_gates Ptr Tensor
_hx Ptr Tensor
_input_bias =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _input_gates)
  , *$(at::Tensor* _hidden_gates)
  , *$(at::Tensor* _hx)
  , *$(at::Tensor* _input_bias)));
  }|]

_thnn_fused_gru_cell_out_ttttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_thnn_fused_gru_cell_out_ttttt :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_thnn_fused_gru_cell_out_ttttt Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_input_gates Ptr Tensor
_hidden_gates Ptr Tensor
_hx =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_thnn_fused_gru_cell_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _input_gates)
  , *$(at::Tensor* _hidden_gates)
  , *$(at::Tensor* _hx)));
  }|]

_thnn_fused_gru_cell_backward_out_tttttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor,Tensor,Tensor,Tensor)))
_thnn_fused_gru_cell_backward_out_tttttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor, Tensor, Tensor, Tensor)))
_thnn_fused_gru_cell_backward_out_tttttttb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_out2 Ptr Tensor
_out3 Ptr Tensor
_out4 Ptr Tensor
_grad_hy Ptr Tensor
_workspace CBool
_has_bias =
  [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::_thnn_fused_gru_cell_backward_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _out2)
  , *$(at::Tensor* _out3)
  , *$(at::Tensor* _out4)
  , *$(at::Tensor* _grad_hy)
  , *$(at::Tensor* _workspace)
  , $(bool _has_bias)));
  }|]

_pack_padded_sequence_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr (StdTuple '(Tensor,Tensor)))
_pack_padded_sequence_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr (StdTuple '(Tensor, Tensor)))
_pack_padded_sequence_out_ttttb Ptr Tensor
_out0 Ptr Tensor
_out1 Ptr Tensor
_input Ptr Tensor
_lengths CBool
_batch_first =
  [C.throwBlock| std::tuple<at::Tensor,at::Tensor>* { return new std::tuple<at::Tensor,at::Tensor>(at::_pack_padded_sequence_out(
    *$(at::Tensor* _out0)
  , *$(at::Tensor* _out1)
  , *$(at::Tensor* _input)
  , *$(at::Tensor* _lengths)
  , $(bool _batch_first)));
  }|]

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

set_tS
  :: Ptr Tensor
  -> Ptr Storage
  -> IO (Ptr Tensor)
set_tS :: Ptr Tensor -> Ptr Storage -> IO (Ptr Tensor)
set_tS Ptr Tensor
_self Ptr Storage
_source =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::set(
    *$(at::Tensor* _self)
  , *$(at::Storage* _source)));
  }|]

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

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

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

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

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

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

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

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

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

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

masked_fill_out_ttts
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Scalar
  -> IO (Ptr Tensor)
masked_fill_out_ttts :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Scalar -> IO (Ptr Tensor)
masked_fill_out_ttts Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_mask Ptr Scalar
_value =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::masked_fill_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _mask)
  , *$(at::Scalar* _value)));
  }|]

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

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

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

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

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

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

_masked_softmax_backward_out_tttt
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> IO (Ptr Tensor)
_masked_softmax_backward_out_tttt :: Ptr Tensor
-> Ptr Tensor -> Ptr Tensor -> Ptr Tensor -> IO (Ptr Tensor)
_masked_softmax_backward_out_tttt Ptr Tensor
_out Ptr Tensor
_grad_output Ptr Tensor
_output Ptr Tensor
_mask =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::_masked_softmax_backward_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _grad_output)
  , *$(at::Tensor* _output)
  , *$(at::Tensor* _mask)));
  }|]

put_out_ttttb
  :: Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> Ptr Tensor
  -> CBool
  -> IO (Ptr Tensor)
put_out_ttttb :: Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> Ptr Tensor
-> CBool
-> IO (Ptr Tensor)
put_out_ttttb Ptr Tensor
_out Ptr Tensor
_self Ptr Tensor
_index Ptr Tensor
_source CBool
_accumulate =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::put_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , *$(at::Tensor* _index)
  , *$(at::Tensor* _source)
  , $(bool _accumulate)));
  }|]

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

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

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

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

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

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

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

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

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

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

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

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

random_out_ttllG
  :: Ptr Tensor
  -> Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Generator
  -> IO (Ptr Tensor)
random_out_ttllG :: Ptr Tensor
-> Ptr Tensor -> Int64 -> Int64 -> Ptr Generator -> IO (Ptr Tensor)
random_out_ttllG Ptr Tensor
_out Ptr Tensor
_self Int64
_from Int64
_to Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random_out(
    *$(at::Tensor* _out)
  , *$(at::Tensor* _self)
  , $(int64_t _from)
  , $(int64_t _to)
  , *$(at::Generator* _generator)));
  }|]

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

random_tllG
  :: Ptr Tensor
  -> Int64
  -> Int64
  -> Ptr Generator
  -> IO (Ptr Tensor)
random_tllG :: Ptr Tensor -> Int64 -> Int64 -> Ptr Generator -> IO (Ptr Tensor)
random_tllG Ptr Tensor
_self Int64
_from Int64
_to Ptr Generator
_generator =
  [C.throwBlock| at::Tensor* { return new at::Tensor(at::random(
    *$(at::Tensor* _self)
  , $(int64_t _from)
  , $(int64_t _to)
  , *$(at::Generator* _generator)));
  }|]