#pragma once

// @generated by aten/src/ATen/gen.py from TypeDerived.h

#include <c10/core/TensorOptions.h>
#include <c10/core/Scalar.h>
#include <c10/core/QScheme.h>
#include <c10/core/MemoryFormat.h>
#include <c10/util/ArrayRef.h>
#include <c10/util/intrusive_ptr.h>
#include <torch/csrc/WindowsTorchApiMacro.h>
#include <ATen/Dimname.h>



namespace c10 {
struct Storage;
}

namespace at {

class Tensor;
using TensorList = ArrayRef<Tensor>;

class Context;
struct Generator;

struct Quantizer;
// This is temporary typedef to enable Quantizer in aten native function API
// we'll remove them when we are actually exposing Quantizer class
// to frontend
using ConstQuantizerPtr = const c10::intrusive_ptr<Quantizer>&;

namespace CPUType {
  Tensor & abs_out_out(Tensor & out, const Tensor & self);
  Tensor & angle_out_out(Tensor & out, const Tensor & self);
  Tensor & sgn_out_out(Tensor & out, const Tensor & self);
  Tensor & conj_out_out(Tensor & out, const Tensor & self);
  Tensor & acos_out_out(Tensor & out, const Tensor & self);
  Tensor add_Tensor(const Tensor & self, const Tensor & other, Scalar alpha);
  Tensor & add__Tensor(Tensor & self, const Tensor & other, Scalar alpha);
  Tensor & add_out_out(Tensor & out, const Tensor & self, const Tensor & other, Scalar alpha);
  Tensor _add_relu_Tensor(const Tensor & self, const Tensor & other, Scalar alpha);
  Tensor & _add_relu__Tensor(Tensor & self, const Tensor & other, Scalar alpha);
  Tensor & _add_relu_out_out(Tensor & out, const Tensor & self, const Tensor & other, Scalar alpha);
  Tensor addmv(const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha);
  Tensor & addmv_(Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha);
  Tensor & addmv_out_out(Tensor & out, const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha);
  Tensor & _addmv_impl_(Tensor & self, const Tensor & self2, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha);
  Tensor all_dim(const Tensor & self, int64_t dim, bool keepdim);
  Tensor & all_out_out(Tensor & out, const Tensor & self, int64_t dim, bool keepdim);
  Tensor any_dim(const Tensor & self, int64_t dim, bool keepdim);
  Tensor & any_out_out(Tensor & out, const Tensor & self, int64_t dim, bool keepdim);
  Tensor & arange_out_start_out(Tensor & out, Scalar start, Scalar end, Scalar step);
  Tensor argmax(const Tensor & self, c10::optional<int64_t> dim, bool keepdim);
  Tensor argmin(const Tensor & self, c10::optional<int64_t> dim, bool keepdim);
  Tensor & acosh_out_out(Tensor & out, const Tensor & self);
  Tensor & asinh_out_out(Tensor & out, const Tensor & self);
  Tensor & atanh_out_out(Tensor & out, const Tensor & self);
  Tensor as_strided(const Tensor & self, IntArrayRef size, IntArrayRef stride, c10::optional<int64_t> storage_offset);
  Tensor & asin_(Tensor & self);
  Tensor & asin_out_out(Tensor & out, const Tensor & self);
  Tensor & atan_out_out(Tensor & out, const Tensor & self);
  Tensor baddbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha);
  Tensor & baddbmm_(Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha);
  Tensor & baddbmm_out_out(Tensor & out, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha);
  Tensor & bernoulli_out_out(Tensor & out, const Tensor & self, c10::optional<Generator> generator);
  Tensor & bernoulli__Tensor(Tensor & self, const Tensor & p, c10::optional<Generator> generator);
  Tensor & bernoulli__float(Tensor & self, double p, c10::optional<Generator> generator);
  Tensor binary_cross_entropy(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
  Tensor & binary_cross_entropy_out_out(Tensor & out, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
  Tensor binary_cross_entropy_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
  Tensor & binary_cross_entropy_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
  Tensor bincount(const Tensor & self, const Tensor & weights, int64_t minlength);
  Tensor & bitwise_not_out_out(Tensor & out, const Tensor & self);
  Tensor & logical_not_out_out(Tensor & out, const Tensor & self);
  Tensor & logical_xor_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & logical_and_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & logical_or_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor bmm(const Tensor & self, const Tensor & mat2);
  Tensor & bmm_out_out(Tensor & out, const Tensor & self, const Tensor & mat2);
  Tensor & ceil_out_out(Tensor & out, const Tensor & self);
  Tensor clamp(const Tensor & self, c10::optional<Scalar> min, c10::optional<Scalar> max);
  Tensor & clamp_out_out(Tensor & out, const Tensor & self, c10::optional<Scalar> min, c10::optional<Scalar> max);
  Tensor & clamp_max_out_out(Tensor & out, const Tensor & self, Scalar max);
  Tensor & clamp_min_out_out(Tensor & out, const Tensor & self, Scalar min);
  Tensor & complex_out_out(Tensor & out, const Tensor & real, const Tensor & imag);
  Tensor & polar_out_out(Tensor & out, const Tensor & abs, const Tensor & angle);
  Tensor & cos_out_out(Tensor & out, const Tensor & self);
  Tensor & cosh_out_out(Tensor & out, const Tensor & self);
  Tensor count_nonzero_dim_IntList(const Tensor & self, IntArrayRef dim);
  void _cummax_helper(const Tensor & self, Tensor & values, Tensor & indices, int64_t dim);
  void _cummin_helper(const Tensor & self, Tensor & values, Tensor & indices, int64_t dim);
  std::tuple<Tensor,Tensor> _ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank, bool zero_infinity);
  Tensor _ctc_loss_backward(const Tensor & grad, const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, const Tensor & neg_log_likelihood, const Tensor & log_alpha, int64_t blank, bool zero_infinity);
  Tensor div_Tensor(const Tensor & self, const Tensor & other);
  Tensor & div__Tensor(Tensor & self, const Tensor & other);
  Tensor & div_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor dot(const Tensor & self, const Tensor & tensor);
  Tensor vdot(const Tensor & self, const Tensor & other);
  Tensor embedding_dense_backward(const Tensor & grad_output, const Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq);
  Tensor & embedding_renorm_(Tensor & self, const Tensor & indices, double max_norm, double norm_type);
  std::tuple<Tensor,Tensor,Tensor,Tensor> _embedding_bag_forward_only(const Tensor & weight, const Tensor & indices, const Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const Tensor & per_sample_weights, bool include_last_offset);
  std::tuple<Tensor,Tensor,Tensor,Tensor> _embedding_bag(const Tensor & weight, const Tensor & indices, const Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const Tensor & per_sample_weights, bool include_last_offset);
  Tensor _embedding_bag_dense_backward(const Tensor & grad, const Tensor & indices, const Tensor & offsets, const Tensor & offset2bag, const Tensor & bag_size, const Tensor & maximum_indices, int64_t num_weights, bool scale_grad_by_freq, int64_t mode, const Tensor & per_sample_weights);
  Tensor _embedding_bag_per_sample_weights_backward(const Tensor & grad, const Tensor & weight, const Tensor & indices, const Tensor & offsets, const Tensor & offset2bag, int64_t mode);
  Tensor empty_memory_format(IntArrayRef size, const TensorOptions & options, c10::optional<MemoryFormat> memory_format);
  Tensor _empty_affine_quantized(IntArrayRef size, const TensorOptions & options, double scale, int64_t zero_point, c10::optional<MemoryFormat> memory_format);
  Tensor _empty_per_channel_affine_quantized(IntArrayRef size, const Tensor & scales, const Tensor & zero_points, int64_t axis, const TensorOptions & options, c10::optional<MemoryFormat> memory_format);
  Tensor & resize_(Tensor & self, IntArrayRef size, c10::optional<MemoryFormat> memory_format);
  Tensor empty_strided(IntArrayRef size, IntArrayRef stride, const TensorOptions & options);
  Tensor & erf_out_out(Tensor & out, const Tensor & self);
  Tensor & erfc_out_out(Tensor & out, const Tensor & self);
  Tensor & exp_out_out(Tensor & out, const Tensor & self);
  Tensor & exp2_out_out(Tensor & out, const Tensor & self);
  Tensor & expm1_out_out(Tensor & out, const Tensor & self);
  Tensor & eye_out_out(Tensor & out, int64_t n);
  Tensor & eye_out_m_out(Tensor & out, int64_t n, int64_t m);
  Tensor & floor_out_out(Tensor & out, const Tensor & self);
  Tensor floor_divide(const Tensor & self, const Tensor & other);
  Tensor & floor_divide__Tensor(Tensor & self, const Tensor & other);
  Tensor & floor_divide_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & frac_out_out(Tensor & out, const Tensor & self);
  Tensor from_file(std::string filename, c10::optional<bool> shared, c10::optional<int64_t> size, const TensorOptions & options);
  Tensor & gcd_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & lcm_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor grid_sampler_2d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
  std::tuple<Tensor,Tensor> grid_sampler_2d_backward(const Tensor & grad_output, const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
  Tensor grid_sampler_3d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
  std::tuple<Tensor,Tensor> grid_sampler_3d_backward(const Tensor & grad_output, const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
  std::tuple<Tensor,Tensor,Tensor> native_group_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps);
  std::tuple<Tensor,Tensor,Tensor> native_group_norm_backward(const Tensor & grad_out, const Tensor & input, const Tensor & mean, const Tensor & rstd, const Tensor & weight, int64_t N, int64_t C, int64_t HxW, int64_t group, std::array<bool,3> output_mask);
  Tensor _fft_with_size_norm_modes(const Tensor & self, int64_t signal_ndim, bool complex_input, bool complex_output, bool inverse, IntArrayRef checked_signal_sizes, int64_t normalization, bool onesided, IntArrayRef output_sizes);
  Tensor index_Tensor(const Tensor & self, TensorList indices);
  Tensor & _index_put_impl_(Tensor & self, TensorList indices, const Tensor & values, bool accumulate, bool unsafe);
  Tensor _inverse_helper(const Tensor & self);
  Tensor isnan(const Tensor & self);
  Tensor kl_div_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, bool log_target);
  std::tuple<Tensor &,Tensor &> kthvalue_out_values(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim, bool keepdim);
  std::tuple<Tensor,Tensor,Tensor> native_layer_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, int64_t M, int64_t N, double eps);
  std::tuple<Tensor,Tensor,Tensor> native_layer_norm_backward(const Tensor & grad_out, const Tensor & input, const Tensor & mean, const Tensor & rstd, const Tensor & weight, int64_t M, int64_t N, std::array<bool,3> output_mask);
  Tensor & linspace_out_out(Tensor & out, Scalar start, Scalar end, c10::optional<int64_t> steps);
  Tensor & log_out_out(Tensor & out, const Tensor & self);
  Tensor & log10_out_out(Tensor & out, const Tensor & self);
  Tensor & log1p_(Tensor & self);
  Tensor & log1p_out_out(Tensor & out, const Tensor & self);
  Tensor & log2_out_out(Tensor & out, const Tensor & self);
  Tensor & logaddexp_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & logaddexp2_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & logspace_out_out(Tensor & out, Scalar start, Scalar end, c10::optional<int64_t> steps, double base);
  Tensor _log_softmax(const Tensor & self, int64_t dim, bool half_to_float);
  Tensor _log_softmax_backward_data(const Tensor & grad_output, const Tensor & output, int64_t dim, const Tensor & self);
  Tensor _logcumsumexp(const Tensor & self, int64_t dim);
  Tensor & _logcumsumexp_out_out(Tensor & out, const Tensor & self, int64_t dim);
  Tensor matrix_exp(const Tensor & self);
  std::tuple<Tensor,Tensor> _aminmax(const Tensor & self);
  std::tuple<Tensor,Tensor> _aminmax_dim(const Tensor & self, int64_t dim, bool keepdim);
  Tensor _compute_linear_combination(const Tensor & input, const Tensor & coefficients);
  Tensor & _compute_linear_combination_out_out(Tensor & out, const Tensor & input, const Tensor & coefficients);
  std::tuple<Tensor &,Tensor &> max_out_dim_max(Tensor & max, Tensor & max_values, const Tensor & self, int64_t dim, bool keepdim);
  Tensor & amax_out_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim);
  Tensor mean(const Tensor & self, c10::optional<ScalarType> dtype);
  Tensor mean_dim(const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype);
  Tensor & mean_out_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype);
  std::tuple<Tensor &,Tensor &> min_out_dim_min(Tensor & min, Tensor & min_indices, const Tensor & self, int64_t dim, bool keepdim);
  Tensor & amin_out_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim);
  Tensor mm(const Tensor & self, const Tensor & mat2);
  Tensor & mm_out_out(Tensor & out, const Tensor & self, const Tensor & mat2);
  std::tuple<Tensor,Tensor> mode(const Tensor & self, int64_t dim, bool keepdim);
  Tensor mul_Tensor(const Tensor & self, const Tensor & other);
  Tensor & mul__Tensor(Tensor & self, const Tensor & other);
  Tensor & mul_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor mv(const Tensor & self, const Tensor & vec);
  Tensor narrow_copy(const Tensor & self, int64_t dim, int64_t start, int64_t length);
  std::tuple<Tensor,Tensor,Tensor> native_batch_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & running_mean, const Tensor & running_var, bool training, double momentum, double eps);
  std::tuple<Tensor,Tensor,Tensor> native_batch_norm_backward(const Tensor & grad_out, const Tensor & input, const Tensor & weight, const Tensor & running_mean, const Tensor & running_var, const Tensor & save_mean, const Tensor & save_invstd, bool train, double eps, std::array<bool,3> output_mask);
  std::tuple<Tensor,Tensor> batch_norm_update_stats(const Tensor & input, const Tensor & running_mean, const Tensor & running_var, double momentum);
  Tensor _cdist_forward(const Tensor & x1, const Tensor & x2, double p, c10::optional<int64_t> compute_mode);
  Tensor _cdist_backward(const Tensor & grad, const Tensor & x1, const Tensor & x2, double p, const Tensor & cdist);
  Tensor _pdist_forward(const Tensor & self, double p);
  Tensor _pdist_backward(const Tensor & grad, const Tensor & self, double p, const Tensor & pdist);
  Tensor channel_shuffle(const Tensor & self, int64_t groups);
  Tensor & randperm_out_generator_out(Tensor & out, int64_t n, c10::optional<Generator> generator);
  Tensor & range_out_out(Tensor & out, Scalar start, Scalar end, Scalar step);
  Tensor & reciprocal_out_out(Tensor & out, const Tensor & self);
  Tensor & neg_(Tensor & self);
  Tensor & neg_out_out(Tensor & out, const Tensor & self);
  Tensor repeat_interleave_Tensor(const Tensor & repeats);
  Tensor & round_out_out(Tensor & out, const Tensor & self);
  Tensor relu(const Tensor & self);
  Tensor & relu_(Tensor & self);
  Tensor prelu(const Tensor & self, const Tensor & weight);
  std::tuple<Tensor,Tensor> prelu_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight);
  Tensor gelu(const Tensor & self);
  Tensor gelu_backward(const Tensor & grad, const Tensor & self);
  Tensor hardshrink(const Tensor & self, Scalar lambd);
  Tensor hardshrink_backward(const Tensor & grad_out, const Tensor & self, Scalar lambd);
  Tensor & rsqrt_out_out(Tensor & out, const Tensor & self);
  Tensor & silu_out_out(Tensor & out, const Tensor & self);
  Tensor sigmoid(const Tensor & self);
  Tensor & sigmoid_(Tensor & self);
  Tensor & sigmoid_out_out(Tensor & out, const Tensor & self);
  Tensor logit(const Tensor & self, c10::optional<double> eps);
  Tensor & logit_(Tensor & self, c10::optional<double> eps);
  Tensor & logit_out_out(Tensor & out, const Tensor & self, c10::optional<double> eps);
  Tensor & sin_out_out(Tensor & out, const Tensor & self);
  Tensor & sinh_out_out(Tensor & out, const Tensor & self);
  Tensor _softmax(const Tensor & self, int64_t dim, bool half_to_float);
  Tensor _softmax_backward_data(const Tensor & grad_output, const Tensor & output, int64_t dim, const Tensor & self);
  Tensor & sspaddmm_out_out(Tensor & out, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha);
  Tensor sum(const Tensor & self, c10::optional<ScalarType> dtype);
  Tensor sum_dim_IntList(const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype);
  Tensor & sum_out_IntList_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype);
  Tensor nansum(const Tensor & self, c10::optional<ScalarType> dtype);
  Tensor nansum_dim_IntList(const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype);
  Tensor & nansum_out_IntList_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype);
  Tensor & sqrt_out_out(Tensor & out, const Tensor & self);
  Tensor std(const Tensor & self, bool unbiased);
  Tensor std_dim(const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim);
  std::tuple<Tensor,Tensor> std_mean(const Tensor & self, bool unbiased);
  std::tuple<Tensor,Tensor> std_mean_dim(const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim);
  Tensor & std_out_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim);
  Tensor prod(const Tensor & self, c10::optional<ScalarType> dtype);
  Tensor prod_dim_int(const Tensor & self, int64_t dim, bool keepdim, c10::optional<ScalarType> dtype);
  Tensor & prod_out_int_out(Tensor & out, const Tensor & self, int64_t dim, bool keepdim, c10::optional<ScalarType> dtype);
  Tensor & tan_out_out(Tensor & out, const Tensor & self);
  Tensor tanh(const Tensor & self);
  Tensor & tanh_out_out(Tensor & out, const Tensor & self);
  Tensor threshold(const Tensor & self, Scalar threshold, Scalar value);
  Tensor & threshold_(Tensor & self, Scalar threshold, Scalar value);
  Tensor & threshold_out_out(Tensor & out, const Tensor & self, Scalar threshold, Scalar value);
  Tensor threshold_backward(const Tensor & grad_output, const Tensor & self, Scalar threshold);
  Tensor flip(const Tensor & self, IntArrayRef dims);
  Tensor roll(const Tensor & self, IntArrayRef shifts, IntArrayRef dims);
  Tensor & trunc_out_out(Tensor & out, const Tensor & self);
  std::tuple<Tensor,Tensor> _unique(const Tensor & self, bool sorted, bool return_inverse);
  std::tuple<Tensor,Tensor,Tensor> unique_dim(const Tensor & self, int64_t dim, bool sorted, bool return_inverse, bool return_counts);
  std::tuple<Tensor,Tensor,Tensor> unique_consecutive(const Tensor & self, bool return_inverse, bool return_counts, c10::optional<int64_t> dim);
  std::tuple<Tensor,Tensor,Tensor> unique_dim_consecutive(const Tensor & self, int64_t dim, bool return_inverse, bool return_counts);
  std::tuple<Tensor,Tensor,Tensor> _unique2(const Tensor & self, bool sorted, bool return_inverse, bool return_counts);
  Tensor var(const Tensor & self, bool unbiased);
  Tensor var_dim(const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim);
  Tensor & var_out_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim);
  std::tuple<Tensor,Tensor> var_mean(const Tensor & self, bool unbiased);
  std::tuple<Tensor,Tensor> var_mean_dim(const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim);
  Tensor _s_where(const Tensor & condition, const Tensor & self, const Tensor & other);
  Tensor _standard_gamma_grad(const Tensor & self, const Tensor & output);
  Tensor _standard_gamma(const Tensor & self, c10::optional<Generator> generator);
  Tensor _dirichlet_grad(const Tensor & x, const Tensor & alpha, const Tensor & total);
  Tensor _sample_dirichlet(const Tensor & self, c10::optional<Generator> generator);
  Tensor poisson(const Tensor & self, c10::optional<Generator> generator);
  Tensor binomial(const Tensor & count, const Tensor & prob, c10::optional<Generator> generator);
  Tensor & norm_out_dtype_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim, ScalarType dtype);
  Tensor & norm_out_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim);
  Tensor clone(const Tensor & self, c10::optional<MemoryFormat> memory_format);
  Tensor & zero_(Tensor & self);
  Tensor & sub_out_out(Tensor & out, const Tensor & self, const Tensor & other, Scalar alpha);
  Tensor sub_Tensor(const Tensor & self, const Tensor & other, Scalar alpha);
  Tensor & sub__Tensor(Tensor & self, const Tensor & other, Scalar alpha);
  Tensor rsub_Tensor(const Tensor & self, const Tensor & other, Scalar alpha);
  Tensor & heaviside_out_out(Tensor & out, const Tensor & self, const Tensor & values);
  Tensor & addmm_out_out(Tensor & out, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha);
  Tensor addmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha);
  Tensor & addmm_(Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha);
  Tensor to_sparse_sparse_dim(const Tensor & self, int64_t sparse_dim);
  Tensor to_sparse(const Tensor & self);
  Tensor to_mkldnn(const Tensor & self);
  Tensor quantize_per_tensor(const Tensor & self, double scale, int64_t zero_point, ScalarType dtype);
  std::vector<Tensor> quantize_per_tensor_tensors(TensorList tensors, const Tensor & scales, const Tensor & zero_points, ScalarType dtype);
  Tensor quantize_per_channel(const Tensor & self, const Tensor & scales, const Tensor & zero_points, int64_t axis, ScalarType dtype);
  Tensor _make_per_tensor_quantized_tensor(const Tensor & self, double scale, int64_t zero_point);
  Tensor _make_per_channel_quantized_tensor(const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis);
  Tensor fake_quantize_per_tensor_affine(const Tensor & self, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max);
  Tensor _fake_quantize_learnable_per_tensor_affine(const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t quant_min, int64_t quant_max);
  Tensor fake_quantize_per_channel_affine(const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max);
  Tensor _fake_quantize_learnable_per_channel_affine(const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max);
  Scalar _local_scalar_dense(const Tensor & self);
  Tensor & set__source_Storage(Tensor & self, Storage source);
  Tensor & set__source_Storage_storage_offset(Tensor & self, Storage source, int64_t storage_offset, IntArrayRef size, IntArrayRef stride);
  Tensor & set__source_Tensor(Tensor & self, const Tensor & source);
  Tensor & set_(Tensor & self);
  bool is_set_to(const Tensor & self, const Tensor & tensor);
  Tensor & masked_fill__Scalar(Tensor & self, const Tensor & mask, Scalar value);
  Tensor & masked_fill__Tensor(Tensor & self, const Tensor & mask, const Tensor & value);
  Tensor & masked_scatter_(Tensor & self, const Tensor & mask, const Tensor & source);
  Tensor view(const Tensor & self, IntArrayRef size);
  Tensor & put_(Tensor & self, const Tensor & index, const Tensor & source, bool accumulate);
  Tensor & index_add_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & source);
  Tensor & index_fill__int_Scalar(Tensor & self, int64_t dim, const Tensor & index, Scalar value);
  Tensor & index_fill__int_Tensor(Tensor & self, int64_t dim, const Tensor & index, const Tensor & value);
  Tensor & scatter__src(Tensor & self, int64_t dim, const Tensor & index, const Tensor & src);
  Tensor & scatter__value(Tensor & self, int64_t dim, const Tensor & index, Scalar value);
  Tensor & scatter__reduce(Tensor & self, int64_t dim, const Tensor & index, const Tensor & src, std::string reduce);
  Tensor & scatter__value_reduce(Tensor & self, int64_t dim, const Tensor & index, Scalar value, std::string reduce);
  Tensor & scatter_add_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & src);
  Tensor & bitwise_and_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & bitwise_and_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor & bitwise_or_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & bitwise_or_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor & bitwise_xor_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor & bitwise_xor_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor __lshift___Scalar(const Tensor & self, Scalar other);
  Tensor __lshift___Tensor(const Tensor & self, const Tensor & other);
  Tensor & __ilshift___Scalar(Tensor & self, Scalar other);
  Tensor & __ilshift___Tensor(Tensor & self, const Tensor & other);
  Tensor __rshift___Scalar(const Tensor & self, Scalar other);
  Tensor __rshift___Tensor(const Tensor & self, const Tensor & other);
  Tensor & __irshift___Scalar(Tensor & self, Scalar other);
  Tensor & __irshift___Tensor(Tensor & self, const Tensor & other);
  Tensor & lgamma_(Tensor & self);
  Tensor & atan2_(Tensor & self, const Tensor & other);
  Tensor & tril_(Tensor & self, int64_t diagonal);
  Tensor & triu_(Tensor & self, int64_t diagonal);
  Tensor & digamma_(Tensor & self);
  Tensor & renorm_(Tensor & self, Scalar p, int64_t dim, Scalar maxnorm);
  Tensor & pow__Scalar(Tensor & self, Scalar exponent);
  Tensor & pow__Tensor(Tensor & self, const Tensor & exponent);
  Tensor & lerp__Scalar(Tensor & self, const Tensor & end, Scalar weight);
  Tensor & lerp__Tensor(Tensor & self, const Tensor & end, const Tensor & weight);
  Tensor & fmod__Scalar(Tensor & self, Scalar other);
  Tensor & fmod__Tensor(Tensor & self, const Tensor & other);
  Tensor & remainder__Scalar(Tensor & self, Scalar other);
  Tensor & remainder__Tensor(Tensor & self, const Tensor & other);
  Tensor & addbmm_(Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha);
  Tensor & addbmm_out_out(Tensor & out, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha);
  Tensor addbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha);
  Tensor & random__from(Tensor & self, int64_t from, c10::optional<int64_t> to, c10::optional<Generator> generator);
  Tensor & random__to(Tensor & self, int64_t to, c10::optional<Generator> generator);
  Tensor & random_(Tensor & self, c10::optional<Generator> generator);
  Tensor & uniform_(Tensor & self, double from, double to, c10::optional<Generator> generator);
  Tensor & cauchy_(Tensor & self, double median, double sigma, c10::optional<Generator> generator);
  Tensor & log_normal_(Tensor & self, double mean, double std, c10::optional<Generator> generator);
  Tensor & exponential_(Tensor & self, double lambd, c10::optional<Generator> generator);
  Tensor & geometric_(Tensor & self, double p, c10::optional<Generator> generator);
  Tensor & diag_out_out(Tensor & out, const Tensor & self, int64_t diagonal);
  Tensor & cross_out_out(Tensor & out, const Tensor & self, const Tensor & other, c10::optional<int64_t> dim);
  Tensor cross(const Tensor & self, const Tensor & other, c10::optional<int64_t> dim);
  Tensor & triu_out_out(Tensor & out, const Tensor & self, int64_t diagonal);
  Tensor & tril_out_out(Tensor & out, const Tensor & self, int64_t diagonal);
  Tensor tril_indices(int64_t row, int64_t col, int64_t offset, const TensorOptions & options);
  Tensor triu_indices(int64_t row, int64_t col, int64_t offset, const TensorOptions & options);
  Tensor trace(const Tensor & self);
  Tensor & ne_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor ne_Scalar(const Tensor & self, Scalar other);
  Tensor & ne_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor ne_Tensor(const Tensor & self, const Tensor & other);
  Tensor & eq_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor eq_Scalar(const Tensor & self, Scalar other);
  Tensor & eq_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor eq_Tensor(const Tensor & self, const Tensor & other);
  Tensor & ge_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor ge_Scalar(const Tensor & self, Scalar other);
  Tensor & ge_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor ge_Tensor(const Tensor & self, const Tensor & other);
  Tensor & le_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor le_Scalar(const Tensor & self, Scalar other);
  Tensor & le_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor le_Tensor(const Tensor & self, const Tensor & other);
  Tensor & gt_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor gt_Scalar(const Tensor & self, Scalar other);
  Tensor & gt_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor gt_Tensor(const Tensor & self, const Tensor & other);
  Tensor & lt_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor lt_Scalar(const Tensor & self, Scalar other);
  Tensor & lt_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor lt_Tensor(const Tensor & self, const Tensor & other);
  Tensor & take_out_out(Tensor & out, const Tensor & self, const Tensor & index);
  Tensor take(const Tensor & self, const Tensor & index);
  Tensor & index_select_out_out(Tensor & out, const Tensor & self, int64_t dim, const Tensor & index);
  Tensor index_select(const Tensor & self, int64_t dim, const Tensor & index);
  Tensor & masked_select_out_out(Tensor & out, const Tensor & self, const Tensor & mask);
  Tensor masked_select(const Tensor & self, const Tensor & mask);
  Tensor & nonzero_out_out(Tensor & out, const Tensor & self);
  Tensor nonzero(const Tensor & self);
  Tensor & gather_out_out(Tensor & out, const Tensor & self, int64_t dim, const Tensor & index, bool sparse_grad);
  Tensor gather(const Tensor & self, int64_t dim, const Tensor & index, bool sparse_grad);
  Tensor & addcmul_out_out(Tensor & out, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value);
  Tensor & addcdiv_out_out(Tensor & out, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value);
  std::tuple<Tensor &,Tensor &> lstsq_out_X(Tensor & X, Tensor & qr, const Tensor & self, const Tensor & A);
  std::tuple<Tensor,Tensor> lstsq(const Tensor & self, const Tensor & A);
  std::tuple<Tensor,Tensor> _triangular_solve_helper(const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular);
  std::tuple<Tensor,Tensor> _symeig_helper(const Tensor & self, bool eigenvectors, bool upper);
  std::tuple<Tensor &,Tensor &> eig_out_e(Tensor & e, Tensor & v, const Tensor & self, bool eigenvectors);
  std::tuple<Tensor,Tensor> eig(const Tensor & self, bool eigenvectors);
  std::tuple<Tensor,Tensor,Tensor> _svd_helper(const Tensor & self, bool some, bool compute_uv);
  Tensor _cholesky_helper(const Tensor & self, bool upper);
  Tensor _cholesky_solve_helper(const Tensor & self, const Tensor & A, bool upper);
  std::tuple<Tensor,Tensor> _solve_helper(const Tensor & self, const Tensor & A);
  Tensor & cholesky_inverse_out_out(Tensor & out, const Tensor & self, bool upper);
  Tensor cholesky_inverse(const Tensor & self, bool upper);
  std::tuple<Tensor,Tensor> _qr_helper(const Tensor & self, bool some);
  std::tuple<Tensor &,Tensor &> geqrf_out_a(Tensor & a, Tensor & tau, const Tensor & self);
  std::tuple<Tensor,Tensor> geqrf(const Tensor & self);
  Tensor & orgqr_out_out(Tensor & out, const Tensor & self, const Tensor & input2);
  Tensor orgqr(const Tensor & self, const Tensor & input2);
  Tensor & ormqr_out_out(Tensor & out, const Tensor & self, const Tensor & input2, const Tensor & input3, bool left, bool transpose);
  Tensor ormqr(const Tensor & self, const Tensor & input2, const Tensor & input3, bool left, bool transpose);
  std::tuple<Tensor,Tensor,Tensor> _lu_with_info(const Tensor & self, bool pivot, bool check_errors);
  Tensor _lu_solve_helper(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots);
  Tensor & multinomial_out_out(Tensor & out, const Tensor & self, int64_t num_samples, bool replacement, c10::optional<Generator> generator);
  Tensor multinomial(const Tensor & self, int64_t num_samples, bool replacement, c10::optional<Generator> generator);
  std::tuple<Tensor,Tensor> _multinomial_alias_setup(const Tensor & probs);
  Tensor _multinomial_alias_draw(const Tensor & J, const Tensor & q, int64_t num_samples, c10::optional<Generator> generator);
  Tensor & lgamma_out_out(Tensor & out, const Tensor & self);
  Tensor lgamma(const Tensor & self);
  Tensor & digamma_out_out(Tensor & out, const Tensor & self);
  Tensor digamma(const Tensor & self);
  Tensor & polygamma_out_out(Tensor & out, int64_t n, const Tensor & self);
  Tensor erfinv(const Tensor & self);
  Tensor & erfinv_(Tensor & self);
  Tensor & erfinv_out_out(Tensor & out, const Tensor & self);
  Tensor & i0_out_out(Tensor & out, const Tensor & self);
  Tensor & sign_out_out(Tensor & out, const Tensor & self);
  Tensor & signbit_out_out(Tensor & out, const Tensor & self);
  Tensor & atan2_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor atan2(const Tensor & self, const Tensor & other);
  Tensor & lerp_out_Scalar_out(Tensor & out, const Tensor & self, const Tensor & end, Scalar weight);
  Tensor & lerp_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & end, const Tensor & weight);
  Tensor lerp_Scalar(const Tensor & self, const Tensor & end, Scalar weight);
  Tensor lerp_Tensor(const Tensor & self, const Tensor & end, const Tensor & weight);
  Tensor & histc_out_out(Tensor & out, const Tensor & self, int64_t bins, Scalar min, Scalar max);
  Tensor histc(const Tensor & self, int64_t bins, Scalar min, Scalar max);
  Tensor & fmod_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor fmod_Scalar(const Tensor & self, Scalar other);
  Tensor & fmod_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor fmod_Tensor(const Tensor & self, const Tensor & other);
  Tensor & hypot_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor hypot(const Tensor & self, const Tensor & other);
  Tensor & nextafter_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor nextafter(const Tensor & self, const Tensor & other);
  Tensor & remainder_out_Scalar_out(Tensor & out, const Tensor & self, Scalar other);
  Tensor remainder_Scalar(const Tensor & self, Scalar other);
  Tensor & remainder_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor remainder_Tensor(const Tensor & self, const Tensor & other);
  Tensor min(const Tensor & self);
  Tensor max(const Tensor & self);
  Tensor maximum(const Tensor & self, const Tensor & other);
  Tensor & maximum_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor minimum(const Tensor & self, const Tensor & other);
  Tensor & minimum_out_out(Tensor & out, const Tensor & self, const Tensor & other);
  Tensor median(const Tensor & self);
  std::tuple<Tensor &,Tensor &> sort_out_values(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool descending);
  std::tuple<Tensor,Tensor> sort(const Tensor & self, int64_t dim, bool descending);
  std::tuple<Tensor &,Tensor &> topk_out_values(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted);
  std::tuple<Tensor,Tensor> topk(const Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted);
  Tensor all(const Tensor & self);
  Tensor any(const Tensor & self);
  Tensor & renorm_out_out(Tensor & out, const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm);
  Tensor renorm(const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm);
  Tensor unfold(const Tensor & self, int64_t dimension, int64_t size, int64_t step);
  Tensor unfold_backward(const Tensor & grad_in, IntArrayRef input_sizes, int64_t dim, int64_t size, int64_t step);
  bool equal(const Tensor & self, const Tensor & other);
  Tensor & pow_out_Tensor_Tensor_out(Tensor & out, const Tensor & self, const Tensor & exponent);
  Tensor pow_Tensor_Tensor(const Tensor & self, const Tensor & exponent);
  Tensor & pow_out_Scalar_out(Tensor & out, Scalar self, const Tensor & exponent);
  Tensor pow_Scalar(Scalar self, const Tensor & exponent);
  Tensor & pow_out_Tensor_Scalar_out(Tensor & out, const Tensor & self, Scalar exponent);
  Tensor pow_Tensor_Scalar(const Tensor & self, Scalar exponent);
  Tensor & normal_(Tensor & self, double mean, double std, c10::optional<Generator> generator);
  Tensor & normal_out_Tensor_float_out(Tensor & out, const Tensor & mean, double std, c10::optional<Generator> generator);
  Tensor normal_Tensor_float(const Tensor & mean, double std, c10::optional<Generator> generator);
  Tensor & normal_out_float_Tensor_out(Tensor & out, double mean, const Tensor & std, c10::optional<Generator> generator);
  Tensor normal_float_Tensor(double mean, const Tensor & std, c10::optional<Generator> generator);
  Tensor & normal_out_Tensor_Tensor_out(Tensor & out, const Tensor & mean, const Tensor & std, c10::optional<Generator> generator);
  Tensor normal_Tensor_Tensor(const Tensor & mean, const Tensor & std, c10::optional<Generator> generator);
  Tensor & _index_copy_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & source);
  Tensor _cumsum(const Tensor & self, int64_t dim);
  Tensor & _cumsum_out_out(Tensor & out, const Tensor & self, int64_t dim);
  Tensor _cumprod(const Tensor & self, int64_t dim);
  Tensor & _cumprod_out_out(Tensor & out, const Tensor & self, int64_t dim);
  Tensor _var(const Tensor & self, bool unbiased);
  Tensor _std(const Tensor & self, bool unbiased);
  Tensor _cat(TensorList tensors, int64_t dim);
  Tensor & _cat_out_out(Tensor & out, TensorList tensors, int64_t dim);
  std::vector<Tensor> _foreach_add_Scalar(TensorList tensors, Scalar scalar);
  void _foreach_add__Scalar(TensorList self, Scalar scalar);
  std::vector<Tensor> _foreach_sub_Scalar(TensorList tensors, Scalar scalar);
  void _foreach_sub__Scalar(TensorList self, Scalar scalar);
  std::vector<Tensor> _foreach_mul_Scalar(TensorList tensors, Scalar scalar);
  void _foreach_mul__Scalar(TensorList self, Scalar scalar);
  std::vector<Tensor> _foreach_div_Scalar(TensorList tensors, Scalar scalar);
  void _foreach_div__Scalar(TensorList self, Scalar scalar);
  std::vector<Tensor> _foreach_add_List(TensorList tensors1, TensorList tensors2, Scalar alpha);
  void _foreach_add__List(TensorList self, TensorList other, Scalar alpha);
  std::vector<Tensor> _foreach_sub_List(TensorList tensors1, TensorList tensors2, Scalar alpha);
  void _foreach_sub__List(TensorList self, TensorList other, Scalar alpha);
  std::vector<Tensor> _foreach_mul_List(TensorList tensors1, TensorList tensors2);
  void _foreach_mul__List(TensorList self, TensorList other);
  std::vector<Tensor> _foreach_div_List(TensorList tensors1, TensorList tensors2);
  void _foreach_div__List(TensorList self, TensorList other);
  std::vector<Tensor> _foreach_add_scalar_list(TensorList tensors, ArrayRef<double> scalars);
  void _foreach_add_scalar_list_(TensorList self, ArrayRef<double> scalars);
  std::vector<Tensor> _foreach_sub_scalar_list(TensorList tensors, ArrayRef<double> scalars);
  void _foreach_sub_scalar_list_(TensorList self, ArrayRef<double> scalars);
  std::vector<Tensor> _foreach_div_scalar_list(TensorList tensors, ArrayRef<double> scalars);
  void _foreach_div_scalar_list_(TensorList self, ArrayRef<double> scalars);
  std::vector<Tensor> _foreach_mul_scalar_list(TensorList tensors, ArrayRef<double> scalars);
  void _foreach_mul_scalar_list_(TensorList self, ArrayRef<double> scalars);
  std::vector<Tensor> _foreach_exp(TensorList tensors);
  void _foreach_exp_(TensorList self);
  std::vector<Tensor> _foreach_sqrt(TensorList tensors);
  void _foreach_sqrt_(TensorList self);
  void _foreach_addcdiv_(TensorList self, TensorList tensor1, TensorList tensor2, Scalar value);
  void _foreach_addcmul_(TensorList self, TensorList tensor1, TensorList tensor2, Scalar value);
  std::vector<Tensor> _foreach_addcdiv(TensorList input, TensorList tensor1, TensorList tensor2, Scalar value);
  std::vector<Tensor> _foreach_addcmul(TensorList input, TensorList tensor1, TensorList tensor2, Scalar value);
  std::tuple<Tensor,Tensor> _mode(const Tensor & self, int64_t dim, bool keepdim);
  std::tuple<Tensor &,Tensor &> _mode_out_values(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim);
  Tensor bucketize_Tensor(const Tensor & self, const Tensor & boundaries, bool out_int32, bool right);
  Tensor & bucketize_out_Tensor_out(Tensor & out, const Tensor & self, const Tensor & boundaries, bool out_int32, bool right);
  Tensor bucketize_Scalar(Scalar self, const Tensor & boundaries, bool out_int32, bool right);
  Tensor searchsorted_Tensor(const Tensor & sorted_sequence, const Tensor & self, bool out_int32, bool right);
  Tensor & searchsorted_out_Tensor_out(Tensor & out, const Tensor & sorted_sequence, const Tensor & self, bool out_int32, bool right);
  Tensor searchsorted_Scalar(const Tensor & sorted_sequence, Scalar self, bool out_int32, bool right);
  Tensor & mse_loss_out_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction);
  Tensor mse_loss(const Tensor & self, const Tensor & target, int64_t reduction);
  Tensor & mse_loss_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
  Tensor mse_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
  Tensor & l1_loss_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
  Tensor & multi_margin_loss_out_out(Tensor & out, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
  Tensor multi_margin_loss(const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
  Tensor & multi_margin_loss_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
  Tensor multi_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
  std::tuple<Tensor &,Tensor &> multilabel_margin_loss_forward_out_output(Tensor & output, Tensor & is_target, const Tensor & self, const Tensor & target, int64_t reduction);
  std::tuple<Tensor,Tensor> multilabel_margin_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction);
  Tensor & multilabel_margin_loss_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target);
  Tensor multilabel_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target);
  std::tuple<Tensor &,Tensor &> nll_loss_forward_out_output(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
  std::tuple<Tensor,Tensor> nll_loss_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
  Tensor & nll_loss_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index, const Tensor & total_weight);
  Tensor nll_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index, const Tensor & total_weight);
  std::tuple<Tensor &,Tensor &> nll_loss2d_forward_out_output(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
  std::tuple<Tensor,Tensor> nll_loss2d_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
  Tensor & nll_loss2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index, const Tensor & total_weight);
  Tensor nll_loss2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index, const Tensor & total_weight);
  Tensor & smooth_l1_loss_out_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction, double beta);
  Tensor smooth_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction, double beta);
  Tensor & smooth_l1_loss_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, double beta);
  Tensor & elu_out_out(Tensor & out, const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale);
  Tensor elu(const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale);
  Tensor & elu_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output);
  Tensor elu_backward(const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output);
  Tensor & glu_out_out(Tensor & out, const Tensor & self, int64_t dim);
  Tensor glu(const Tensor & self, int64_t dim);
  Tensor & glu_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, int64_t dim);
  Tensor glu_backward(const Tensor & grad_output, const Tensor & self, int64_t dim);
  Tensor & hardsigmoid_out_out(Tensor & out, const Tensor & self);
  Tensor hardsigmoid(const Tensor & self);
  Tensor & hardsigmoid_(Tensor & self);
  Tensor hardsigmoid_backward(const Tensor & grad_output, const Tensor & self);
  Tensor & hardtanh_out_out(Tensor & out, const Tensor & self, Scalar min_val, Scalar max_val);
  Tensor hardtanh(const Tensor & self, Scalar min_val, Scalar max_val);
  Tensor & hardtanh_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val);
  Tensor hardtanh_backward(const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val);
  Tensor & hardtanh_(Tensor & self, Scalar min_val, Scalar max_val);
  Tensor & hardswish_out_out(Tensor & out, const Tensor & self);
  Tensor hardswish(const Tensor & self);
  Tensor & hardswish_(Tensor & self);
  Tensor hardswish_backward(const Tensor & grad_output, const Tensor & self);
  Tensor & leaky_relu_out_out(Tensor & out, const Tensor & self, Scalar negative_slope);
  Tensor leaky_relu(const Tensor & self, Scalar negative_slope);
  Tensor leaky_relu_backward(const Tensor & grad_output, const Tensor & self, Scalar negative_slope, bool self_is_result);
  Tensor & leaky_relu_(Tensor & self, Scalar negative_slope);
  std::tuple<Tensor &,Tensor &> log_sigmoid_forward_out_output(Tensor & output, Tensor & buffer, const Tensor & self);
  std::tuple<Tensor,Tensor> log_sigmoid_forward(const Tensor & self);
  Tensor & log_sigmoid_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & buffer);
  Tensor log_sigmoid_backward(const Tensor & grad_output, const Tensor & self, const Tensor & buffer);
  Tensor & rrelu_with_noise_out_out(Tensor & out, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, c10::optional<Generator> generator);
  Tensor rrelu_with_noise(const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, c10::optional<Generator> generator);
  Tensor & rrelu_with_noise_(Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, c10::optional<Generator> generator);
  Tensor & softplus_out_out(Tensor & out, const Tensor & self, Scalar beta, Scalar threshold);
  Tensor softplus(const Tensor & self, Scalar beta, Scalar threshold);
  Tensor & softplus_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output);
  Tensor softplus_backward(const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output);
  Tensor & softshrink_out_out(Tensor & out, const Tensor & self, Scalar lambd);
  Tensor softshrink(const Tensor & self, Scalar lambd);
  Tensor & softshrink_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar lambd);
  Tensor softshrink_backward(const Tensor & grad_output, const Tensor & self, Scalar lambd);
  Tensor & adaptive_avg_pool2d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size);
  Tensor _adaptive_avg_pool2d(const Tensor & self, IntArrayRef output_size);
  Tensor _adaptive_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self);
  Tensor & adaptive_avg_pool3d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size);
  Tensor adaptive_avg_pool3d(const Tensor & self, IntArrayRef output_size);
  Tensor & adaptive_avg_pool3d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self);
  Tensor adaptive_avg_pool3d_backward(const Tensor & grad_output, const Tensor & self);
  std::tuple<Tensor &,Tensor &> adaptive_max_pool2d_out_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef output_size);
  std::tuple<Tensor,Tensor> adaptive_max_pool2d(const Tensor & self, IntArrayRef output_size);
  Tensor & adaptive_max_pool2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices);
  Tensor adaptive_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices);
  std::tuple<Tensor &,Tensor &> adaptive_max_pool3d_out_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef output_size);
  std::tuple<Tensor,Tensor> adaptive_max_pool3d(const Tensor & self, IntArrayRef output_size);
  Tensor & adaptive_max_pool3d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices);
  Tensor adaptive_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices);
  Tensor & avg_pool2d_out_out(Tensor & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
  Tensor avg_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
  Tensor & avg_pool2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
  Tensor avg_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
  Tensor & avg_pool3d_out_out(Tensor & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
  Tensor avg_pool3d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
  Tensor & avg_pool3d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
  Tensor avg_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
  std::tuple<Tensor &,Tensor &> fractional_max_pool2d_out_output(Tensor & output, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples);
  std::tuple<Tensor,Tensor> fractional_max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples);
  Tensor & fractional_max_pool2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices);
  Tensor fractional_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices);
  std::tuple<Tensor &,Tensor &> fractional_max_pool3d_out_output(Tensor & output, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples);
  std::tuple<Tensor,Tensor> fractional_max_pool3d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples);
  Tensor & fractional_max_pool3d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices);
  Tensor fractional_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices);
  std::tuple<Tensor &,Tensor &> max_pool2d_with_indices_out_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode);
  std::tuple<Tensor,Tensor> max_pool2d_with_indices(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode);
  Tensor & max_pool2d_with_indices_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices);
  Tensor max_pool2d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices);
  std::tuple<Tensor &,Tensor &> max_pool3d_with_indices_out_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode);
  std::tuple<Tensor,Tensor> max_pool3d_with_indices(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode);
  Tensor & max_pool3d_with_indices_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices);
  Tensor max_pool3d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices);
  Tensor & max_unpool2d_out_out(Tensor & out, const Tensor & self, const Tensor & indices, IntArrayRef output_size);
  Tensor max_unpool2d(const Tensor & self, const Tensor & indices, IntArrayRef output_size);
  Tensor & max_unpool2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size);
  Tensor max_unpool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size);
  Tensor & max_unpool3d_out_out(Tensor & out, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding);
  Tensor max_unpool3d(const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding);
  Tensor & max_unpool3d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding);
  Tensor max_unpool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding);
  Tensor & reflection_pad1d_out_out(Tensor & out, const Tensor & self, IntArrayRef padding);
  Tensor reflection_pad1d(const Tensor & self, IntArrayRef padding);
  Tensor & reflection_pad1d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor reflection_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor & reflection_pad2d_out_out(Tensor & out, const Tensor & self, IntArrayRef padding);
  Tensor reflection_pad2d(const Tensor & self, IntArrayRef padding);
  Tensor & reflection_pad2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor reflection_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor & replication_pad1d_out_out(Tensor & out, const Tensor & self, IntArrayRef padding);
  Tensor replication_pad1d(const Tensor & self, IntArrayRef padding);
  Tensor & replication_pad1d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor replication_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor & replication_pad2d_out_out(Tensor & out, const Tensor & self, IntArrayRef padding);
  Tensor replication_pad2d(const Tensor & self, IntArrayRef padding);
  Tensor & replication_pad2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor replication_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor & replication_pad3d_out_out(Tensor & out, const Tensor & self, IntArrayRef padding);
  Tensor replication_pad3d(const Tensor & self, IntArrayRef padding);
  Tensor & replication_pad3d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor replication_pad3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
  Tensor upsample_linear1d_vec(const Tensor & input, c10::optional<IntArrayRef> output_size, bool align_corners, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_linear1d_backward_vec(const Tensor & grad_output, c10::optional<IntArrayRef> output_size, IntArrayRef input_size, bool align_corners, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_bilinear2d_vec(const Tensor & input, c10::optional<IntArrayRef> output_size, bool align_corners, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_bilinear2d_backward_vec(const Tensor & grad_output, c10::optional<IntArrayRef> output_size, IntArrayRef input_size, bool align_corners, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_trilinear3d_vec(const Tensor & input, c10::optional<IntArrayRef> output_size, bool align_corners, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_trilinear3d_backward_vec(const Tensor & grad_output, c10::optional<IntArrayRef> output_size, IntArrayRef input_size, bool align_corners, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_bicubic2d_vec(const Tensor & input, c10::optional<IntArrayRef> output_size, bool align_corners, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_bicubic2d_backward_vec(const Tensor & grad_output, c10::optional<IntArrayRef> output_size, IntArrayRef input_size, bool align_corners, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_nearest1d_vec(const Tensor & input, c10::optional<IntArrayRef> output_size, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_nearest1d_backward_vec(const Tensor & grad_output, c10::optional<IntArrayRef> output_size, IntArrayRef input_size, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_nearest2d_vec(const Tensor & input, c10::optional<IntArrayRef> output_size, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_nearest2d_backward_vec(const Tensor & grad_output, c10::optional<IntArrayRef> output_size, IntArrayRef input_size, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_nearest3d_vec(const Tensor & input, c10::optional<IntArrayRef> output_size, c10::optional<ArrayRef<double>> scale_factors);
  Tensor upsample_nearest3d_backward_vec(const Tensor & grad_output, c10::optional<IntArrayRef> output_size, IntArrayRef input_size, c10::optional<ArrayRef<double>> scale_factors);
  Tensor & upsample_linear1d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales);
  Tensor upsample_linear1d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales);
  Tensor & upsample_linear1d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales);
  Tensor upsample_linear1d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales);
  Tensor & upsample_bilinear2d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_bilinear2d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_bilinear2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_bilinear2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_bicubic2d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_bicubic2d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_bicubic2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_bicubic2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_trilinear3d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_trilinear3d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_trilinear3d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_trilinear3d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_nearest1d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales);
  Tensor upsample_nearest1d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales);
  Tensor & upsample_nearest1d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales);
  Tensor upsample_nearest1d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales);
  Tensor & upsample_nearest2d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_nearest2d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_nearest2d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_nearest2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_nearest3d_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_nearest3d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & upsample_nearest3d_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor upsample_nearest3d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
  Tensor & sigmoid_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & output);
  Tensor sigmoid_backward(const Tensor & grad_output, const Tensor & output);
  Tensor & logit_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, c10::optional<double> eps);
  Tensor logit_backward(const Tensor & grad_output, const Tensor & self, c10::optional<double> eps);
  Tensor & tanh_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, const Tensor & output);
  Tensor tanh_backward(const Tensor & grad_output, const Tensor & output);
  Tensor & slow_conv_transpose2d_out_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation);
  Tensor slow_conv_transpose2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation);
  std::tuple<Tensor &,Tensor &,Tensor &> slow_conv_transpose2d_backward_out_grad_output(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & columns, const Tensor & ones);
  std::tuple<Tensor,Tensor,Tensor> slow_conv_transpose2d_backward_output_mask(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask);
  Tensor & slow_conv_transpose3d_out_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation);
  Tensor slow_conv_transpose3d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation);
  std::tuple<Tensor &,Tensor &,Tensor &> slow_conv_transpose3d_backward_out_grad_output(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & finput, const Tensor & fgrad_input);
  std::tuple<Tensor,Tensor,Tensor> slow_conv_transpose3d_backward_output_mask(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
  std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv2d_forward_out_output(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding);
  std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_forward(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding);
  std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv2d_backward_out_grad_input(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input);
  std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_backward_output_mask(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
  std::tuple<Tensor &,Tensor &,Tensor &> slow_conv3d_forward_out_output(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding);
  std::tuple<Tensor,Tensor,Tensor> slow_conv3d_forward(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding);
  std::tuple<Tensor &,Tensor &,Tensor &> slow_conv3d_backward_out_grad_input(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input);
  std::tuple<Tensor,Tensor,Tensor> slow_conv3d_backward_output_mask(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
  Tensor slow_conv_dilated2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation);
  std::tuple<Tensor,Tensor,Tensor> slow_conv_dilated2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, std::array<bool,3> output_mask);
  Tensor slow_conv_dilated3d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation);
  std::tuple<Tensor,Tensor,Tensor> slow_conv_dilated3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, std::array<bool,3> output_mask);
  Tensor & col2im_out_out(Tensor & out, const Tensor & self, IntArrayRef output_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
  Tensor col2im(const Tensor & self, IntArrayRef output_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
  Tensor & col2im_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
  Tensor col2im_backward(const Tensor & grad_output, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
  Tensor & im2col_out_out(Tensor & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
  Tensor im2col(const Tensor & self, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
  Tensor & im2col_backward_out_grad_input(Tensor & grad_input, const Tensor & grad_output, IntArrayRef input_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
  Tensor im2col_backward(const Tensor & grad_output, IntArrayRef input_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
  Tensor & isposinf_out_out(Tensor & out, const Tensor & self);
  Tensor & isneginf_out_out(Tensor & out, const Tensor & self);
  Tensor _test_optional_intlist(const Tensor & values, c10::optional<IntArrayRef> addends);
  Tensor _test_optional_filled_intlist(const Tensor & values, c10::optional<IntArrayRef> addends);
  Tensor _test_optional_floatlist(const Tensor & values, c10::optional<ArrayRef<double>> addends);
}

} // namespace at
