#pragma once

// @generated by aten/src/ATen/gen.py

#include <c10/core/Scalar.h>
#include "ATen/Type.h"
#include "ATen/TypeExtendedInterface.h"
#include "ATen/Tensor.h"
#include "c10/core/Storage.h"
#include "ATen/core/Generator.h"
#include "ATen/core/Deprecated.h"
#include "ATen/NativeFunctions.h"
#include "ATen/DeviceGuard.h"
#include "ATen/core/TensorOptions.h"
#include "ATen/core/Reduction.h"
#include "c10/util/Optional.h"

namespace at {

using native::from_blob;
using native::tensor;

static inline Tensor & _th_set_(Tensor & self, Storage source);
static inline Tensor & _th_set_(Tensor & self, Storage source, int64_t storage_offset, IntList size, IntList stride={});
static inline Tensor & _th_set_(Tensor & self, const Tensor & source);
static inline Tensor & _th_set_(Tensor & self);
static inline Tensor & _th_fill_(Tensor & self, Scalar value);
static inline Tensor & _th_fill_(Tensor & self, const Tensor & value);
static inline bool _th_is_set_to(const Tensor & self, const Tensor & tensor);
static inline Tensor & _th_masked_fill_(Tensor & self, const Tensor & mask, Scalar value);
static inline Tensor & _th_masked_fill_(Tensor & self, const Tensor & mask, const Tensor & value);
static inline Tensor & _th_masked_scatter_(Tensor & self, const Tensor & mask, const Tensor & source);
static inline Tensor & _th_masked_select_out(Tensor & result, const Tensor & self, const Tensor & mask);
static inline Tensor _th_masked_select(const Tensor & self, const Tensor & mask);
static inline Tensor & _th_nonzero_out(Tensor & result, const Tensor & self);
static inline Tensor _th_nonzero(const Tensor & self);
static inline Tensor _th_clone(const Tensor & self);
static inline Tensor _th_view(const Tensor & self, IntList size);
static inline Tensor & _th_resize_as_(Tensor & self, const Tensor & the_template);
static inline Tensor & _th_index_select_out(Tensor & result, const Tensor & self, int64_t dim, const Tensor & index);
static inline Tensor _th_index_select(const Tensor & self, int64_t dim, const Tensor & index);
static inline Tensor & _th_index_copy_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & source);
static inline Tensor & _th_take_out(Tensor & result, const Tensor & self, const Tensor & index);
static inline Tensor _th_take(const Tensor & self, const Tensor & index);
static inline Tensor & _th_put_(Tensor & self, const Tensor & index, const Tensor & source, bool accumulate=false);
static inline Tensor & _th_index_add_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & source);
static inline Tensor & _th_index_fill_(Tensor & self, int64_t dim, const Tensor & index, Scalar value);
static inline Tensor & _th_index_fill_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & value);
static inline Tensor & _th_unfold_out(Tensor & result, const Tensor & self, int64_t dimension, int64_t size, int64_t step);
static inline Tensor _th_unfold(const Tensor & self, int64_t dimension, int64_t size, int64_t step);
static inline Tensor & _th_range_out(Tensor & result, Scalar start, Scalar end, Scalar step);
static inline Tensor & _th_arange_out(Tensor & result, Scalar start, Scalar end, Scalar step);
static inline Tensor & _th_arange_out(Tensor & result, Scalar end);
static inline Tensor & _th_scatter_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & src);
static inline Tensor & _th_scatter_(Tensor & self, int64_t dim, const Tensor & index, Scalar value);
static inline Tensor & _th_scatter_add_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & src);
static inline Tensor & _th_gather_out(Tensor & result, const Tensor & self, int64_t dim, const Tensor & index);
static inline Tensor _th_gather(const Tensor & self, int64_t dim, const Tensor & index);
static inline bool _th_equal(const Tensor & self, const Tensor & other);
static inline Tensor & _th_and_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_and(const Tensor & self, Scalar other);
static inline Tensor & _th_and_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_and(const Tensor & self, const Tensor & other);
static inline Tensor & _th_iand_(Tensor & self, Scalar other);
static inline Tensor & _th_iand_(Tensor & self, const Tensor & other);
static inline Tensor & _th_or_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_or(const Tensor & self, Scalar other);
static inline Tensor & _th_or_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_or(const Tensor & self, const Tensor & other);
static inline Tensor & _th_ior_(Tensor & self, Scalar other);
static inline Tensor & _th_ior_(Tensor & self, const Tensor & other);
static inline Tensor & _th_xor_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_xor(const Tensor & self, Scalar other);
static inline Tensor & _th_xor_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_xor(const Tensor & self, const Tensor & other);
static inline Tensor & _th_ixor_(Tensor & self, Scalar other);
static inline Tensor & _th_ixor_(Tensor & self, const Tensor & other);
static inline Tensor & _th_lshift_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_lshift(const Tensor & self, Scalar other);
static inline Tensor & _th_lshift_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_lshift(const Tensor & self, const Tensor & other);
static inline Tensor & _th_ilshift_(Tensor & self, Scalar other);
static inline Tensor & _th_ilshift_(Tensor & self, const Tensor & other);
static inline Tensor & _th_rshift_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_rshift(const Tensor & self, Scalar other);
static inline Tensor & _th_rshift_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_rshift(const Tensor & self, const Tensor & other);
static inline Tensor & _th_irshift_(Tensor & self, Scalar other);
static inline Tensor & _th_irshift_(Tensor & self, const Tensor & other);
static inline Tensor & _th_lt_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_lt(const Tensor & self, Scalar other);
static inline Tensor & _th_lt_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_lt(const Tensor & self, const Tensor & other);
static inline Tensor & _th_lt_(Tensor & self, Scalar other);
static inline Tensor & _th_lt_(Tensor & self, const Tensor & other);
static inline Tensor & _th_gt_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_gt(const Tensor & self, Scalar other);
static inline Tensor & _th_gt_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_gt(const Tensor & self, const Tensor & other);
static inline Tensor & _th_gt_(Tensor & self, Scalar other);
static inline Tensor & _th_gt_(Tensor & self, const Tensor & other);
static inline Tensor & _th_le_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_le(const Tensor & self, Scalar other);
static inline Tensor & _th_le_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_le(const Tensor & self, const Tensor & other);
static inline Tensor & _th_le_(Tensor & self, Scalar other);
static inline Tensor & _th_le_(Tensor & self, const Tensor & other);
static inline Tensor & _th_ge_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_ge(const Tensor & self, Scalar other);
static inline Tensor & _th_ge_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_ge(const Tensor & self, const Tensor & other);
static inline Tensor & _th_ge_(Tensor & self, Scalar other);
static inline Tensor & _th_ge_(Tensor & self, const Tensor & other);
static inline Tensor & _th_eq_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_eq(const Tensor & self, Scalar other);
static inline Tensor & _th_eq_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_eq(const Tensor & self, const Tensor & other);
static inline Tensor & _th_eq_(Tensor & self, Scalar other);
static inline Tensor & _th_eq_(Tensor & self, const Tensor & other);
static inline Tensor & _th_ne_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_ne(const Tensor & self, Scalar other);
static inline Tensor & _th_ne_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_ne(const Tensor & self, const Tensor & other);
static inline Tensor & _th_ne_(Tensor & self, Scalar other);
static inline Tensor & _th_ne_(Tensor & self, const Tensor & other);
static inline Tensor & _th_min_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_min(const Tensor & self, const Tensor & other);
static inline Tensor _th_min(const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> _th_min_out(Tensor & min, Tensor & min_indices, const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> _th_min(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor & _th_max_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_max(const Tensor & self, const Tensor & other);
static inline Tensor _th_max(const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> _th_max_out(Tensor & max, Tensor & max_indices, const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> _th_max(const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> _th_kthvalue_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim=-1, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> _th_kthvalue(const Tensor & self, int64_t k, int64_t dim=-1, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> _th_mode_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim=-1, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> _th_mode(const Tensor & self, int64_t dim=-1, bool keepdim=false);
static inline Tensor _th_median(const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> _th_median_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> _th_median(const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> _th_sort_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim=-1, bool descending=false);
static inline std::tuple<Tensor,Tensor> _th_sort(const Tensor & self, int64_t dim=-1, bool descending=false);
static inline std::tuple<Tensor &,Tensor &> _th_topk_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim=-1, bool largest=true, bool sorted=true);
static inline std::tuple<Tensor,Tensor> _th_topk(const Tensor & self, int64_t k, int64_t dim=-1, bool largest=true, bool sorted=true);
static inline Tensor _th_all(const Tensor & self);
static inline Tensor & _th_all_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor _th_all(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor _th_any(const Tensor & self);
static inline Tensor & _th_any_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor _th_any(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor & _th_abs_out(Tensor & result, const Tensor & self);
static inline Tensor _th_abs(const Tensor & self);
static inline Tensor & _th_sigmoid_out(Tensor & result, const Tensor & self);
static inline Tensor _th_sigmoid(const Tensor & self);
static inline Tensor & _th_log_out(Tensor & result, const Tensor & self);
static inline Tensor _th_log(const Tensor & self);
static inline Tensor & _th_log10_out(Tensor & result, const Tensor & self);
static inline Tensor _th_log10(const Tensor & self);
static inline Tensor & _th_log1p_out(Tensor & result, const Tensor & self);
static inline Tensor _th_log1p(const Tensor & self);
static inline Tensor & _th_log2_out(Tensor & result, const Tensor & self);
static inline Tensor _th_log2(const Tensor & self);
static inline Tensor & _th_lgamma_out(Tensor & result, const Tensor & self);
static inline Tensor _th_lgamma(const Tensor & self);
static inline Tensor & _th_lgamma_(Tensor & self);
static inline Tensor & _th_digamma_out(Tensor & result, const Tensor & self);
static inline Tensor _th_digamma(const Tensor & self);
static inline Tensor & _th_digamma_(Tensor & self);
static inline Tensor & _th_polygamma_out(Tensor & result, int64_t n, const Tensor & self);
static inline Tensor _th_polygamma(int64_t n, const Tensor & self);
static inline Tensor & _th_polygamma_(Tensor & self, int64_t n);
static inline Tensor & _th_exp_out(Tensor & result, const Tensor & self);
static inline Tensor _th_exp(const Tensor & self);
static inline Tensor & _th_expm1_out(Tensor & result, const Tensor & self);
static inline Tensor _th_expm1(const Tensor & self);
static inline Tensor & _th_cos_out(Tensor & result, const Tensor & self);
static inline Tensor _th_cos(const Tensor & self);
static inline Tensor & _th_acos_out(Tensor & result, const Tensor & self);
static inline Tensor _th_acos(const Tensor & self);
static inline Tensor & _th_cosh_out(Tensor & result, const Tensor & self);
static inline Tensor _th_cosh(const Tensor & self);
static inline Tensor & _th_sin_out(Tensor & result, const Tensor & self);
static inline Tensor _th_sin(const Tensor & self);
static inline Tensor & _th_asin_out(Tensor & result, const Tensor & self);
static inline Tensor _th_asin(const Tensor & self);
static inline Tensor & _th_sinh_out(Tensor & result, const Tensor & self);
static inline Tensor _th_sinh(const Tensor & self);
static inline Tensor & _th_tan_out(Tensor & result, const Tensor & self);
static inline Tensor _th_tan(const Tensor & self);
static inline Tensor & _th_atan_out(Tensor & result, const Tensor & self);
static inline Tensor _th_atan(const Tensor & self);
static inline Tensor & _th_tanh_out(Tensor & result, const Tensor & self);
static inline Tensor _th_tanh(const Tensor & self);
static inline Tensor & _th_erf_out(Tensor & result, const Tensor & self);
static inline Tensor _th_erf(const Tensor & self);
static inline Tensor & _th_erfc_out(Tensor & result, const Tensor & self);
static inline Tensor _th_erfc(const Tensor & self);
static inline Tensor & _th_erfinv_(Tensor & self);
static inline Tensor & _th_erfinv_out(Tensor & result, const Tensor & self);
static inline Tensor _th_erfinv(const Tensor & self);
static inline Tensor & _th_sqrt_out(Tensor & result, const Tensor & self);
static inline Tensor _th_sqrt(const Tensor & self);
static inline Tensor & _th_rsqrt_out(Tensor & result, const Tensor & self);
static inline Tensor _th_rsqrt(const Tensor & self);
static inline Tensor & _th_ceil_out(Tensor & result, const Tensor & self);
static inline Tensor _th_ceil(const Tensor & self);
static inline Tensor & _th_floor_out(Tensor & result, const Tensor & self);
static inline Tensor _th_floor(const Tensor & self);
static inline Tensor & _th_round_out(Tensor & result, const Tensor & self);
static inline Tensor _th_round(const Tensor & self);
static inline Tensor & _th_trunc_out(Tensor & result, const Tensor & self);
static inline Tensor _th_trunc(const Tensor & self);
static inline Tensor & _th_frac_(Tensor & self);
static inline Tensor & _th_frac_out(Tensor & result, const Tensor & self);
static inline Tensor _th_frac(const Tensor & self);
static inline Tensor & _th_var_out(Tensor & result, const Tensor & self, int64_t dim, bool unbiased=true, bool keepdim=false);
static inline Tensor _th_var(const Tensor & self, int64_t dim, bool unbiased=true, bool keepdim=false);
static inline Tensor _th_var(const Tensor & self, bool unbiased=true);
static inline Tensor & _th_std_out(Tensor & result, const Tensor & self, int64_t dim, bool unbiased=true, bool keepdim=false);
static inline Tensor _th_std(const Tensor & self, int64_t dim, bool unbiased=true, bool keepdim=false);
static inline Tensor _th_std(const Tensor & self, bool unbiased=true);
static inline Tensor _th_norm(const Tensor & self, Scalar p=2);
static inline Tensor & _th_norm_out(Tensor & result, const Tensor & self, Scalar p, int64_t dim, bool keepdim=false);
static inline Tensor _th_norm(const Tensor & self, Scalar p, int64_t dim, bool keepdim=false);
static inline Tensor & _th_renorm_out(Tensor & result, const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm);
static inline Tensor _th_renorm(const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm);
static inline Tensor & _th_renorm_(Tensor & self, Scalar p, int64_t dim, Scalar maxnorm);
static inline Tensor _th_dist(const Tensor & self, const Tensor & other, Scalar p=2);
static inline Tensor & _th_reciprocal_out(Tensor & result, const Tensor & self);
static inline Tensor _th_reciprocal(const Tensor & self);
static inline Tensor & _th_reciprocal_(Tensor & self);
static inline Tensor & _th_neg_out(Tensor & result, const Tensor & self);
static inline Tensor _th_neg(const Tensor & self);
static inline Tensor & _th_neg_(Tensor & self);
static inline Tensor & _th_atan2_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_atan2(const Tensor & self, const Tensor & other);
static inline Tensor & _th_atan2_(Tensor & self, const Tensor & other);
static inline Tensor & _th_pow_out(Tensor & result, const Tensor & self, Scalar exponent);
static inline Tensor _th_pow(const Tensor & self, Scalar exponent);
static inline Tensor & _th_pow_out(Tensor & result, const Tensor & self, const Tensor & exponent);
static inline Tensor _th_pow(const Tensor & self, const Tensor & exponent);
static inline Tensor & _th_pow_out(Tensor & result, Scalar self, const Tensor & exponent);
static inline Tensor _th_pow(Scalar self, const Tensor & exponent);
static inline Tensor & _th_pow_(Tensor & self, Scalar exponent);
static inline Tensor & _th_pow_(Tensor & self, const Tensor & exponent);
static inline Tensor & _th_lerp_out(Tensor & result, const Tensor & self, const Tensor & end, Scalar weight);
static inline Tensor _th_lerp(const Tensor & self, const Tensor & end, Scalar weight);
static inline Tensor & _th_lerp_(Tensor & self, const Tensor & end, Scalar weight);
static inline Tensor & _th_linspace_out(Tensor & result, Scalar start, Scalar end, int64_t steps);
static inline Tensor & _th_logspace_out(Tensor & result, Scalar start, Scalar end, int64_t steps);
static inline Tensor & _th_histc_out(Tensor & result, const Tensor & self, int64_t bins=100, Scalar min=0, Scalar max=0);
static inline Tensor _th_histc(const Tensor & self, int64_t bins=100, Scalar min=0, Scalar max=0);
static inline Tensor & _th_zero_(Tensor & self);
static inline Tensor & _th_cumsum_out(Tensor & result, const Tensor & self, int64_t dim);
static inline Tensor _th_cumsum(const Tensor & self, int64_t dim);
static inline Tensor & _th_cumprod_out(Tensor & result, const Tensor & self, int64_t dim);
static inline Tensor _th_cumprod(const Tensor & self, int64_t dim);
static inline Tensor & _th_sign_out(Tensor & result, const Tensor & self);
static inline Tensor _th_sign(const Tensor & self);
static inline Tensor & _th_sign_(Tensor & self);
static inline Tensor _th_trace(const Tensor & self);
static inline Tensor & _th_fmod_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_fmod(const Tensor & self, Scalar other);
static inline Tensor & _th_fmod_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_fmod(const Tensor & self, const Tensor & other);
static inline Tensor & _th_fmod_(Tensor & self, Scalar other);
static inline Tensor & _th_fmod_(Tensor & self, const Tensor & other);
static inline Tensor & _th_remainder_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor _th_remainder(const Tensor & self, Scalar other);
static inline Tensor & _th_remainder_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor _th_remainder(const Tensor & self, const Tensor & other);
static inline Tensor & _th_remainder_(Tensor & self, Scalar other);
static inline Tensor & _th_remainder_(Tensor & self, const Tensor & other);
static inline Tensor & _th_clamp_out(Tensor & result, const Tensor & self, Scalar min, Scalar max);
static inline Tensor _th_clamp(const Tensor & self, Scalar min, Scalar max);
static inline Tensor & _th_clamp_min_out(Tensor & result, const Tensor & self, Scalar min);
static inline Tensor _th_clamp_min(const Tensor & self, Scalar min);
static inline Tensor & _th_clamp_max_out(Tensor & result, const Tensor & self, Scalar max);
static inline Tensor _th_clamp_max(const Tensor & self, Scalar max);
static inline Tensor _th_dot(const Tensor & self, const Tensor & tensor);
static inline Tensor & _th_cross_out(Tensor & result, const Tensor & self, const Tensor & other, int64_t dim=-1);
static inline Tensor _th_cross(const Tensor & self, const Tensor & other, int64_t dim=-1);
static inline Tensor & _th_diag_out(Tensor & result, const Tensor & self, int64_t diagonal=0);
static inline Tensor _th_diag(const Tensor & self, int64_t diagonal=0);
static inline Tensor & _th_addmm_out(Tensor & result, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor _th_addmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_addmm_(Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_addmv_out(Tensor & result, const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta=1, Scalar alpha=1);
static inline Tensor _th_addmv(const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_addmv_(Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_addr_out(Tensor & result, const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor _th_addr(const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_addr_(Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_ger_out(Tensor & result, const Tensor & self, const Tensor & vec2);
static inline Tensor _th_ger(const Tensor & self, const Tensor & vec2);
static inline Tensor & _th_mv_out(Tensor & result, const Tensor & self, const Tensor & vec);
static inline Tensor _th_mv(const Tensor & self, const Tensor & vec);
static inline Tensor & _th_mm_out(Tensor & result, const Tensor & self, const Tensor & mat2);
static inline Tensor _th_mm(const Tensor & self, const Tensor & mat2);
static inline Tensor & _th_bmm_out(Tensor & result, const Tensor & self, const Tensor & mat2);
static inline Tensor _th_bmm(const Tensor & self, const Tensor & mat2);
static inline Tensor & _th_addbmm_out(Tensor & result, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor _th_addbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_addbmm_(Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_baddbmm_out(Tensor & result, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor _th_baddbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _th_addcmul_out(Tensor & result, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline Tensor _th_addcmul(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline Tensor & _th_addcmul_(Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline Tensor & _th_addcdiv_out(Tensor & result, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline Tensor _th_addcdiv(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline Tensor & _th_addcdiv_(Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline std::tuple<Tensor &,Tensor &> _th_gesv_single_out(Tensor & solution, Tensor & lu, const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor,Tensor> _th_gesv_single(const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor &,Tensor &> _th_gels_out(Tensor & res1, Tensor & res2, const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor,Tensor> _th_gels(const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor &,Tensor &> _th_trtrs_out(Tensor & res1, Tensor & res2, const Tensor & self, const Tensor & A, bool upper=true, bool transpose=false, bool unitriangular=false);
static inline std::tuple<Tensor,Tensor> _th_trtrs(const Tensor & self, const Tensor & A, bool upper=true, bool transpose=false, bool unitriangular=false);
static inline std::tuple<Tensor &,Tensor &> _th_symeig_out(Tensor & res1, Tensor & res2, const Tensor & self, bool eigenvectors=false, bool upper=true);
static inline std::tuple<Tensor,Tensor> _th_symeig(const Tensor & self, bool eigenvectors=false, bool upper=true);
static inline std::tuple<Tensor &,Tensor &> _th_eig_out(Tensor & res1, Tensor & res2, const Tensor & self, bool eigenvectors=false);
static inline std::tuple<Tensor,Tensor> _th_eig(const Tensor & self, bool eigenvectors=false);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _th_svd_out(Tensor & res1, Tensor & res2, Tensor & res3, const Tensor & self, bool some=true, bool compute_uv=true);
static inline std::tuple<Tensor,Tensor,Tensor> _th_svd(const Tensor & self, bool some=true, bool compute_uv=true);
static inline Tensor & _th_getri_single_out(Tensor & output, const Tensor & self);
static inline Tensor _th_getri_single(const Tensor & self);
static inline Tensor & _th_potrf_single_out(Tensor & output, const Tensor & self, bool upper=true);
static inline Tensor _th_potrf_single(const Tensor & self, bool upper=true);
static inline Tensor & _th_potrs_single_out(Tensor & result, const Tensor & self, const Tensor & input2, bool upper=true);
static inline Tensor _th_potrs_single(const Tensor & self, const Tensor & input2, bool upper=true);
static inline Tensor & _th_potri_out(Tensor & output, const Tensor & self, bool upper=true);
static inline Tensor _th_potri(const Tensor & self, bool upper=true);
static inline std::tuple<Tensor &,Tensor &> _th_pstrf_out(Tensor & res1, Tensor & res2, const Tensor & self, bool upper=true, Scalar tol=-1);
static inline std::tuple<Tensor,Tensor> _th_pstrf(const Tensor & self, bool upper=true, Scalar tol=-1);
static inline std::tuple<Tensor &,Tensor &> _th_qr_out(Tensor & res1, Tensor & res2, const Tensor & self);
static inline std::tuple<Tensor,Tensor> _th_qr(const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> _th_geqrf_out(Tensor & res1, Tensor & res2, const Tensor & self);
static inline std::tuple<Tensor,Tensor> _th_geqrf(const Tensor & self);
static inline Tensor & _th_orgqr_out(Tensor & result, const Tensor & self, const Tensor & input2);
static inline Tensor _th_orgqr(const Tensor & self, const Tensor & input2);
static inline Tensor & _th_ormqr_out(Tensor & result, const Tensor & self, const Tensor & input2, const Tensor & input3, bool left=true, bool transpose=false);
static inline Tensor _th_ormqr(const Tensor & self, const Tensor & input2, const Tensor & input3, bool left=true, bool transpose=false);
static inline std::tuple<Tensor &,Tensor &> _th_btrifact_out(Tensor & result, Tensor & pivots, const Tensor & self, bool pivot=true);
static inline std::tuple<Tensor,Tensor> _th_btrifact(const Tensor & self, bool pivot=true);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _th_btrifact_with_info_out(Tensor & result, Tensor & pivots, Tensor & info, const Tensor & self, bool pivot=true);
static inline std::tuple<Tensor,Tensor,Tensor> _th_btrifact_with_info(const Tensor & self, bool pivot=true);
static inline Tensor & _th_btrisolve_out(Tensor & result, const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots);
static inline Tensor _th_btrisolve(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots);
static inline Tensor & _th_random_(Tensor & self, int64_t from, int64_t to, Generator * generator=nullptr);
static inline Tensor & _th_random_(Tensor & self, int64_t to, Generator * generator=nullptr);
static inline Tensor & _th_random_(Tensor & self, Generator * generator=nullptr);
static inline Tensor & _th_multinomial_out(Tensor & result, const Tensor & self, int64_t num_samples, bool replacement=false, Generator * generator=nullptr);
static inline Tensor _th_multinomial(const Tensor & self, int64_t num_samples, bool replacement=false, Generator * generator=nullptr);
static inline Tensor & _th_uniform_(Tensor & self, double from=0, double to=1, Generator * generator=nullptr);
static inline Tensor & _th_normal_out(Tensor & output, const Tensor & mean, double std=1, Generator * generator=nullptr);
static inline Tensor _th_normal(const Tensor & mean, double std=1, Generator * generator=nullptr);
static inline Tensor & _th_normal_out(Tensor & output, double mean, const Tensor & std, Generator * generator=nullptr);
static inline Tensor _th_normal(double mean, const Tensor & std, Generator * generator=nullptr);
static inline Tensor & _th_normal_out(Tensor & output, const Tensor & mean, const Tensor & std, Generator * generator=nullptr);
static inline Tensor _th_normal(const Tensor & mean, const Tensor & std, Generator * generator=nullptr);
static inline Tensor & _th_normal_(Tensor & self, double mean=0, double std=1, Generator * generator=nullptr);
static inline Tensor & _th_cauchy_(Tensor & self, double median=0, double sigma=1, Generator * generator=nullptr);
static inline Tensor & _th_log_normal_(Tensor & self, double mean=1, double std=2, Generator * generator=nullptr);
static inline Tensor & _th_exponential_(Tensor & self, double lambd=1, Generator * generator=nullptr);
static inline Tensor & _th_geometric_(Tensor & self, double p, Generator * generator=nullptr);
static inline Tensor & _th_dirichlet_grad_out(Tensor & output, const Tensor & x, const Tensor & alpha, const Tensor & total);
static inline Tensor _th_dirichlet_grad(const Tensor & x, const Tensor & alpha, const Tensor & total);
static inline Tensor _th_alias(const Tensor & self);
static inline Tensor & _th_copy_ignoring_overlaps_(Tensor & self, const Tensor & src);
static inline Tensor & _th_cat_out(Tensor & self, TensorList tensors, int64_t dim=0);
static inline Tensor _th_cat(TensorList tensors, int64_t dim=0);
static inline Tensor & _thnn_binary_cross_entropy_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean);
static inline Tensor _thnn_binary_cross_entropy(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean);
static inline Tensor & _thnn_binary_cross_entropy_forward_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
static inline Tensor _thnn_binary_cross_entropy_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
static inline Tensor & _thnn_binary_cross_entropy_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
static inline Tensor _thnn_binary_cross_entropy_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
static inline Tensor & _thnn_l1_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor _thnn_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor & _thnn_l1_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor _thnn_l1_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor _thnn_l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_mse_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor _thnn_mse_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor & _thnn_mse_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor _thnn_mse_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_mse_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor _thnn_mse_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_multi_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, Scalar p=1, Scalar margin=1, const Tensor & weight={}, int64_t reduction=Reduction::Mean);
static inline Tensor _thnn_multi_margin_loss(const Tensor & self, const Tensor & target, Scalar p=1, Scalar margin=1, const Tensor & weight={}, int64_t reduction=Reduction::Mean);
static inline Tensor & _thnn_multi_margin_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
static inline Tensor _thnn_multi_margin_loss_forward(const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
static inline Tensor & _thnn_multi_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
static inline Tensor _thnn_multi_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
static inline Tensor & _thnn_multilabel_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor _thnn_multilabel_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline std::tuple<Tensor &,Tensor &> _thnn_multilabel_margin_loss_forward_out(Tensor & output, Tensor & is_target, const Tensor & self, const Tensor & target, int64_t reduction);
static inline std::tuple<Tensor,Tensor> _thnn_multilabel_margin_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_multilabel_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target);
static inline Tensor _thnn_multilabel_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target);
static inline Tensor & _thnn_nll_loss_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean, int64_t ignore_index=-100);
static inline Tensor _thnn_nll_loss(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean, int64_t ignore_index=-100);
static inline std::tuple<Tensor &,Tensor &> _thnn_nll_loss_forward_out(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
static inline std::tuple<Tensor,Tensor> _thnn_nll_loss_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
static inline Tensor & _thnn_nll_loss_backward_out(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);
static inline Tensor _thnn_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);
static inline Tensor & _thnn_nll_loss2d_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean, int64_t ignore_index=-100);
static inline Tensor _thnn_nll_loss2d(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean, int64_t ignore_index=-100);
static inline std::tuple<Tensor &,Tensor &> _thnn_nll_loss2d_forward_out(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
static inline std::tuple<Tensor,Tensor> _thnn_nll_loss2d_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
static inline Tensor & _thnn_nll_loss2d_backward_out(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);
static inline Tensor _thnn_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);
static inline Tensor & _thnn_smooth_l1_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor _thnn_smooth_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor & _thnn_smooth_l1_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor _thnn_smooth_l1_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_smooth_l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor _thnn_smooth_l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_soft_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor _thnn_soft_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor & _thnn_soft_margin_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor _thnn_soft_margin_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_soft_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor _thnn_soft_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & _thnn_elu_out(Tensor & output, const Tensor & self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1);
static inline Tensor _thnn_elu(const Tensor & self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1);
static inline Tensor & _thnn_elu_forward_out(Tensor & output, const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale);
static inline Tensor _thnn_elu_forward(const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale);
static inline Tensor & _thnn_elu_backward_out(Tensor & grad_input, const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output);
static inline Tensor _thnn_elu_backward(const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output);
static inline Tensor & _thnn_elu_(Tensor & self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1);
static inline Tensor & _thnn_elu_forward_(Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale);
static inline Tensor & _thnn_glu_out(Tensor & output, const Tensor & self, int64_t dim=-1);
static inline Tensor _thnn_glu(const Tensor & self, int64_t dim=-1);
static inline Tensor & _thnn_glu_forward_out(Tensor & output, const Tensor & self, int64_t dim);
static inline Tensor _thnn_glu_forward(const Tensor & self, int64_t dim);
static inline Tensor & _thnn_glu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, int64_t dim);
static inline Tensor _thnn_glu_backward(const Tensor & grad_output, const Tensor & self, int64_t dim);
static inline Tensor & _thnn_hardtanh_out(Tensor & output, const Tensor & self, Scalar min_val=-1, Scalar max_val=1);
static inline Tensor _thnn_hardtanh(const Tensor & self, Scalar min_val=-1, Scalar max_val=1);
static inline Tensor & _thnn_hardtanh_forward_out(Tensor & output, const Tensor & self, Scalar min_val, Scalar max_val);
static inline Tensor _thnn_hardtanh_forward(const Tensor & self, Scalar min_val, Scalar max_val);
static inline Tensor & _thnn_hardtanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val);
static inline Tensor _thnn_hardtanh_backward(const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val);
static inline Tensor & _thnn_hardtanh_(Tensor & self, Scalar min_val=-1, Scalar max_val=1);
static inline Tensor & _thnn_hardtanh_forward_(Tensor & self, Scalar min_val, Scalar max_val);
static inline Tensor & _thnn_leaky_relu_out(Tensor & output, const Tensor & self, Scalar negative_slope=0.01);
static inline Tensor _thnn_leaky_relu(const Tensor & self, Scalar negative_slope=0.01);
static inline Tensor & _thnn_leaky_relu_forward_out(Tensor & output, const Tensor & self, Scalar negative_slope);
static inline Tensor _thnn_leaky_relu_forward(const Tensor & self, Scalar negative_slope);
static inline Tensor & _thnn_leaky_relu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar negative_slope);
static inline Tensor _thnn_leaky_relu_backward(const Tensor & grad_output, const Tensor & self, Scalar negative_slope);
static inline Tensor & _thnn_leaky_relu_(Tensor & self, Scalar negative_slope=0.01);
static inline Tensor & _thnn_leaky_relu_forward_(Tensor & self, Scalar negative_slope);
static inline Tensor & _thnn_log_sigmoid_out(Tensor & output, const Tensor & self);
static inline Tensor _thnn_log_sigmoid(const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> _thnn_log_sigmoid_forward_out(Tensor & output, Tensor & buffer, const Tensor & self);
static inline std::tuple<Tensor,Tensor> _thnn_log_sigmoid_forward(const Tensor & self);
static inline Tensor & _thnn_log_sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & buffer);
static inline Tensor _thnn_log_sigmoid_backward(const Tensor & grad_output, const Tensor & self, const Tensor & buffer);
static inline Tensor & _thnn_rrelu_with_noise_out(Tensor & output, const Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator * generator=nullptr);
static inline Tensor _thnn_rrelu_with_noise(const Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator * generator=nullptr);
static inline Tensor & _thnn_rrelu_with_noise_forward_out(Tensor & output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator);
static inline Tensor _thnn_rrelu_with_noise_forward(const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator);
static inline Tensor & _thnn_rrelu_with_noise_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training);
static inline Tensor _thnn_rrelu_with_noise_backward(const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training);
static inline Tensor & _thnn_rrelu_with_noise_(Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator * generator=nullptr);
static inline Tensor & _thnn_rrelu_with_noise_forward_(Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator);
static inline Tensor & _thnn_softplus_out(Tensor & output, const Tensor & self, Scalar beta=1, Scalar threshold=20);
static inline Tensor _thnn_softplus(const Tensor & self, Scalar beta=1, Scalar threshold=20);
static inline Tensor & _thnn_softplus_forward_out(Tensor & output, const Tensor & self, Scalar beta, Scalar threshold);
static inline Tensor _thnn_softplus_forward(const Tensor & self, Scalar beta, Scalar threshold);
static inline Tensor & _thnn_softplus_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output);
static inline Tensor _thnn_softplus_backward(const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output);
static inline Tensor & _thnn_softshrink_out(Tensor & output, const Tensor & self, Scalar lambd=0.5);
static inline Tensor _thnn_softshrink(const Tensor & self, Scalar lambd=0.5);
static inline Tensor & _thnn_softshrink_forward_out(Tensor & output, const Tensor & self, Scalar lambd);
static inline Tensor _thnn_softshrink_forward(const Tensor & self, Scalar lambd);
static inline Tensor & _thnn_softshrink_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar lambd);
static inline Tensor _thnn_softshrink_backward(const Tensor & grad_output, const Tensor & self, Scalar lambd);
static inline Tensor & _thnn_adaptive_avg_pool2d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_adaptive_avg_pool2d(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_adaptive_avg_pool2d_forward_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_adaptive_avg_pool2d_forward(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_adaptive_avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self);
static inline Tensor _thnn_adaptive_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self);
static inline Tensor & _thnn_adaptive_avg_pool3d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_adaptive_avg_pool3d(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_adaptive_avg_pool3d_forward_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_adaptive_avg_pool3d_forward(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_adaptive_avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self);
static inline Tensor _thnn_adaptive_avg_pool3d_backward(const Tensor & grad_output, const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> _thnn_adaptive_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size);
static inline std::tuple<Tensor,Tensor> _thnn_adaptive_max_pool2d(const Tensor & self, IntList output_size);
static inline std::tuple<Tensor &,Tensor &> _thnn_adaptive_max_pool2d_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size);
static inline std::tuple<Tensor,Tensor> _thnn_adaptive_max_pool2d_forward(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_adaptive_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices);
static inline Tensor _thnn_adaptive_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> _thnn_adaptive_max_pool3d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size);
static inline std::tuple<Tensor,Tensor> _thnn_adaptive_max_pool3d(const Tensor & self, IntList output_size);
static inline std::tuple<Tensor &,Tensor &> _thnn_adaptive_max_pool3d_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size);
static inline std::tuple<Tensor,Tensor> _thnn_adaptive_max_pool3d_forward(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_adaptive_max_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices);
static inline Tensor _thnn_adaptive_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices);
static inline Tensor & _thnn_avg_pool2d_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor _thnn_avg_pool2d(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor & _thnn_avg_pool2d_forward_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor _thnn_avg_pool2d_forward(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor & _thnn_avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor _thnn_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor & _thnn_avg_pool3d_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor _thnn_avg_pool3d(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor & _thnn_avg_pool3d_forward_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor _thnn_avg_pool3d_forward(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor & _thnn_avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor _thnn_avg_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline std::tuple<Tensor &,Tensor &> _thnn_fractional_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples);
static inline std::tuple<Tensor,Tensor> _thnn_fractional_max_pool2d(const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples);
static inline std::tuple<Tensor &,Tensor &> _thnn_fractional_max_pool2d_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples);
static inline std::tuple<Tensor,Tensor> _thnn_fractional_max_pool2d_forward(const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples);
static inline Tensor & _thnn_fractional_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & indices);
static inline Tensor _thnn_fractional_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> _thnn_max_pool2d_with_indices_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline std::tuple<Tensor,Tensor> _thnn_max_pool2d_with_indices(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline std::tuple<Tensor &,Tensor &> _thnn_max_pool2d_with_indices_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode);
static inline std::tuple<Tensor,Tensor> _thnn_max_pool2d_with_indices_forward(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode);
static inline Tensor & _thnn_max_pool2d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor _thnn_max_pool2d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> _thnn_max_pool3d_with_indices_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline std::tuple<Tensor,Tensor> _thnn_max_pool3d_with_indices(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline std::tuple<Tensor &,Tensor &> _thnn_max_pool3d_with_indices_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode);
static inline std::tuple<Tensor,Tensor> _thnn_max_pool3d_with_indices_forward(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode);
static inline Tensor & _thnn_max_pool3d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor _thnn_max_pool3d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor & _thnn_max_unpool2d_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor _thnn_max_unpool2d(const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor & _thnn_max_unpool2d_forward_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor _thnn_max_unpool2d_forward(const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor & _thnn_max_unpool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor _thnn_max_unpool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor & _thnn_max_unpool3d_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor _thnn_max_unpool3d(const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor & _thnn_max_unpool3d_forward_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor _thnn_max_unpool3d_forward(const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor & _thnn_max_unpool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor _thnn_max_unpool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor & _thnn_reflection_pad1d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_reflection_pad1d(const Tensor & self, IntList padding);
static inline Tensor & _thnn_reflection_pad1d_forward_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_reflection_pad1d_forward(const Tensor & self, IntList padding);
static inline Tensor & _thnn_reflection_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor _thnn_reflection_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & _thnn_reflection_pad2d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_reflection_pad2d(const Tensor & self, IntList padding);
static inline Tensor & _thnn_reflection_pad2d_forward_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_reflection_pad2d_forward(const Tensor & self, IntList padding);
static inline Tensor & _thnn_reflection_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor _thnn_reflection_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad1d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad1d(const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad1d_forward_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad1d_forward(const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad2d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad2d(const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad2d_forward_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad2d_forward(const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad3d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad3d(const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad3d_forward_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad3d_forward(const Tensor & self, IntList padding);
static inline Tensor & _thnn_replication_pad3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor _thnn_replication_pad3d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & _thnn_upsample_linear1d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor _thnn_upsample_linear1d(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & _thnn_upsample_linear1d_forward_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor _thnn_upsample_linear1d_forward(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & _thnn_upsample_linear1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor _thnn_upsample_linear1d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor & _thnn_upsample_bilinear2d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor _thnn_upsample_bilinear2d(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & _thnn_upsample_bilinear2d_forward_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor _thnn_upsample_bilinear2d_forward(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & _thnn_upsample_bilinear2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor _thnn_upsample_bilinear2d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor & _thnn_upsample_trilinear3d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor _thnn_upsample_trilinear3d(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & _thnn_upsample_trilinear3d_forward_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor _thnn_upsample_trilinear3d_forward(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & _thnn_upsample_trilinear3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor _thnn_upsample_trilinear3d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor & _thnn_upsample_nearest1d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_upsample_nearest1d(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_upsample_nearest1d_forward_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_upsample_nearest1d_forward(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_upsample_nearest1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor _thnn_upsample_nearest1d_backward(const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor & _thnn_upsample_nearest2d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_upsample_nearest2d(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_upsample_nearest2d_forward_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_upsample_nearest2d_forward(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_upsample_nearest2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor _thnn_upsample_nearest2d_backward(const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor & _thnn_upsample_nearest3d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_upsample_nearest3d(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_upsample_nearest3d_forward_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor _thnn_upsample_nearest3d_forward(const Tensor & self, IntList output_size);
static inline Tensor & _thnn_upsample_nearest3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor _thnn_upsample_nearest3d_backward(const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor & _thnn_sigmoid_out(Tensor & output, const Tensor & self);
static inline Tensor _thnn_sigmoid(const Tensor & self);
static inline Tensor & _thnn_sigmoid_forward_out(Tensor & output, const Tensor & self);
static inline Tensor _thnn_sigmoid_forward(const Tensor & self);
static inline Tensor & _thnn_sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output);
static inline Tensor _thnn_sigmoid_backward(const Tensor & grad_output, const Tensor & output);
static inline Tensor & _thnn_tanh_out(Tensor & output, const Tensor & self);
static inline Tensor _thnn_tanh(const Tensor & self);
static inline Tensor & _thnn_tanh_forward_out(Tensor & output, const Tensor & self);
static inline Tensor _thnn_tanh_forward(const Tensor & self);
static inline Tensor & _thnn_tanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output);
static inline Tensor _thnn_tanh_backward(const Tensor & grad_output, const Tensor & output);
static inline Tensor & _thnn_conv_transpose2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, IntList dilation=1);
static inline Tensor _thnn_conv_transpose2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, IntList dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_transpose2d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_transpose2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_transpose2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & columns, const Tensor & ones);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_transpose2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask={{true, true, true}});
static inline Tensor & _thnn_conv_transpose3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, IntList dilation=1);
static inline Tensor _thnn_conv_transpose3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, IntList dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_transpose3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_transpose3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_transpose3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & finput, const Tensor & fgrad_input);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_transpose3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask={{true, true, true}});
static inline Tensor & _thnn_conv2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0);
static inline Tensor _thnn_conv2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv2d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask={{true, true, true}});
static inline Tensor & _thnn_conv_depthwise2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline Tensor _thnn_conv_depthwise2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline Tensor & _thnn_conv_depthwise2d_forward_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline Tensor _thnn_conv_depthwise2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &> _thnn_conv_depthwise2d_backward_out(Tensor & grad_input, Tensor & grad_weight, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor,Tensor> _thnn_conv_depthwise2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, std::array<bool,2> output_mask={{true, true}});
static inline Tensor & _thnn_conv3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0);
static inline Tensor _thnn_conv3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask={{true, true, true}});
static inline Tensor & _thnn_conv_dilated2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline Tensor _thnn_conv_dilated2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_dilated2d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_dilated2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_dilated2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_dilated2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask={{true, true, true}});
static inline Tensor & _thnn_conv_dilated3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline Tensor _thnn_conv_dilated3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_dilated3d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_dilated3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_dilated3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_dilated3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask={{true, true, true}});
static inline Tensor _cast_Byte(const Tensor & self, bool non_blocking=false);
static inline Tensor _cast_Char(const Tensor & self, bool non_blocking=false);
static inline Tensor _cast_Double(const Tensor & self, bool non_blocking=false);
static inline Tensor _cast_Float(const Tensor & self, bool non_blocking=false);
static inline Tensor _cast_Int(const Tensor & self, bool non_blocking=false);
static inline Tensor _cast_Long(const Tensor & self, bool non_blocking=false);
static inline Tensor _cast_Short(const Tensor & self, bool non_blocking=false);
static inline Tensor _cast_Half(const Tensor & self, bool non_blocking=false);
static inline std::tuple<Tensor,Tensor> _cudnn_ctc_loss(const Tensor & log_probs, const Tensor & targets, IntList input_lengths, IntList target_lengths, int64_t blank, bool deterministic);
static inline Tensor _cudnn_rnn_flatten_weight(TensorList weight_arr, int64_t weight_stride0, int64_t input_size, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, bool bidirectional);
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _cudnn_rnn(const Tensor & input, TensorList weight, int64_t weight_stride0, const Tensor & weight_buf, const Tensor & hx, const Tensor & cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, IntList batch_sizes, const Tensor & dropout_state);
static inline std::tuple<Tensor,Tensor,Tensor,std::vector<Tensor>> _cudnn_rnn_backward(const Tensor & input, TensorList weight, int64_t weight_stride0, const Tensor & weight_buf, const Tensor & hx, const Tensor & cx, const Tensor & output, const Tensor & grad_output, const Tensor & grad_hy, const Tensor & grad_cy, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, IntList batch_sizes, const Tensor & dropout_state, const Tensor & reserve, std::array<bool,4> output_mask);
static inline Tensor _cudnn_init_dropout_state(double dropout, bool train, int64_t dropout_seed, const TensorOptions & options);
static inline std::tuple<Tensor,Tensor> _fused_dropout(const Tensor & self, double p, Generator * generator=nullptr);
static inline Tensor _masked_scale(const Tensor & self, const Tensor & mask, double scale);
static inline Tensor _reshape_from_tensor(const Tensor & self, const Tensor & shape);
static inline Tensor _shape_as_tensor(const Tensor & self);
static inline Tensor dropout(const Tensor & input, double p, bool train);
static inline Tensor & dropout_(Tensor & self, double p, bool train);
static inline Tensor feature_dropout(const Tensor & input, double p, bool train);
static inline Tensor & feature_dropout_(Tensor & self, double p, bool train);
static inline Tensor alpha_dropout(const Tensor & input, double p, bool train);
static inline Tensor & alpha_dropout_(Tensor & self, double p, bool train);
static inline Tensor feature_alpha_dropout(const Tensor & input, double p, bool train);
static inline Tensor & feature_alpha_dropout_(Tensor & self, double p, bool train);
static inline Tensor abs(const Tensor & self);
static inline Tensor & abs_(Tensor & self);
static inline Tensor & abs_out(Tensor & result, const Tensor & self);
static inline Tensor acos(const Tensor & self);
static inline Tensor & acos_(Tensor & self);
static inline Tensor & acos_out(Tensor & result, const Tensor & self);
static inline Tensor avg_pool1d(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor adaptive_avg_pool1d(const Tensor & self, IntList output_size);
static inline std::tuple<Tensor,Tensor> adaptive_max_pool1d(const Tensor & self, IntList output_size);
static inline Tensor add(const Tensor & self, const Tensor & other, Scalar alpha=1);
static inline Tensor & add_out(Tensor & result, const Tensor & self, const Tensor & other, Scalar alpha=1);
static inline Tensor add(const Tensor & self, Scalar other, Scalar alpha=1);
static inline Tensor addmv(const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta=1, Scalar alpha=1);
static inline Tensor & addmv_(Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta=1, Scalar alpha=1);
static inline Tensor & addmv_out(Tensor & result, const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta=1, Scalar alpha=1);
static inline Tensor addr(const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & addr_out(Tensor & result, const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor affine_grid_generator(const Tensor & theta, IntList size);
static inline Tensor affine_grid_generator_backward(const Tensor & grad, IntList size);
static inline Tensor all(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor & all_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim=false);
static inline bool allclose(const Tensor & self, const Tensor & other, double rtol=1e-05, double atol=1e-08, bool equal_nan=false);
static inline Tensor any(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor & any_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor arange(Scalar start, Scalar end, const TensorOptions & options={});
static inline Tensor arange(Scalar start, Scalar end, Scalar step, const TensorOptions & options={});
static inline Tensor & arange_out(Tensor & result, Scalar start, Scalar end);
static inline Tensor & arange_out(Tensor & result, Scalar start, Scalar end, Scalar step);
static inline Tensor arange(Scalar end, const TensorOptions & options={});
static inline Tensor & arange_out(Tensor & result, Scalar end);
static inline Tensor _dim_arange(const Tensor & like, int64_t dim);
static inline Tensor argmax(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor argmax(const Tensor & self);
static inline Tensor _argmax(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor argmin(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor argmin(const Tensor & self);
static inline Tensor _argmin(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor as_strided(const Tensor & self, IntList size, IntList stride);
static inline Tensor & as_strided_(Tensor & self, IntList size, IntList stride);
static inline Tensor as_strided(const Tensor & self, IntList size, IntList stride, int64_t storage_offset);
static inline Tensor & as_strided_(Tensor & self, IntList size, IntList stride, int64_t storage_offset);
static inline Tensor asin(const Tensor & self);
static inline Tensor & asin_(Tensor & self);
static inline Tensor & asin_out(Tensor & result, const Tensor & self);
static inline Tensor atan(const Tensor & self);
static inline Tensor & atan_(Tensor & self);
static inline Tensor & atan_out(Tensor & result, const Tensor & self);
static inline Tensor baddbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _baddbmm_mkl_(Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & baddbmm_out(Tensor & result, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor bartlett_window(int64_t window_length, const TensorOptions & options={});
static inline Tensor bartlett_window(int64_t window_length, bool periodic, const TensorOptions & options={});
static inline Tensor 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, bool cudnn_enabled);
static inline Tensor bernoulli(const Tensor & self, Generator * generator=nullptr);
static inline Tensor & bernoulli_out(Tensor & result, const Tensor & self, Generator * generator=nullptr);
static inline Tensor bernoulli(const Tensor & self, double p, Generator * generator=nullptr);
static inline Tensor bilinear(const Tensor & input1, const Tensor & input2, const Tensor & weight, const Tensor & bias);
static inline Tensor binary_cross_entropy_with_logits(const Tensor & self, const Tensor & target, const Tensor & weight, const Tensor & pos_weight, int64_t reduction);
static inline Tensor binary_cross_entropy_with_logits_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, const Tensor & pos_weight, int64_t reduction);
static inline Tensor bincount(const Tensor & self, const Tensor & weights={}, int64_t minlength=0);
static inline Tensor blackman_window(int64_t window_length, const TensorOptions & options={});
static inline Tensor blackman_window(int64_t window_length, bool periodic, const TensorOptions & options={});
static inline Tensor bmm(const Tensor & self, const Tensor & mat2);
static inline Tensor & bmm_out(Tensor & result, const Tensor & self, const Tensor & mat2);
static inline std::vector<Tensor> broadcast_tensors(TensorList tensors);
static inline Tensor cat(TensorList tensors, int64_t dim=0);
static inline Tensor & cat_out(Tensor & result, TensorList tensors, int64_t dim=0);
static inline Tensor ceil(const Tensor & self);
static inline Tensor & ceil_(Tensor & self);
static inline Tensor & ceil_out(Tensor & result, const Tensor & self);
static inline Tensor chain_matmul(TensorList matrices);
static inline std::vector<Tensor> chunk(const Tensor & self, int64_t chunks, int64_t dim=0);
static inline Tensor clamp(const Tensor & self, c10::optional<Scalar> min=c10::nullopt, c10::optional<Scalar> max=c10::nullopt);
static inline Tensor & clamp_(Tensor & self, c10::optional<Scalar> min=c10::nullopt, c10::optional<Scalar> max=c10::nullopt);
static inline Tensor & clamp_out(Tensor & result, const Tensor & self, c10::optional<Scalar> min=c10::nullopt, c10::optional<Scalar> max=c10::nullopt);
static inline Tensor clamp_max(const Tensor & self, Scalar max);
static inline Tensor & clamp_max_(Tensor & self, Scalar max);
static inline Tensor & clamp_max_out(Tensor & result, const Tensor & self, Scalar max);
static inline Tensor clamp_min(const Tensor & self, Scalar min);
static inline Tensor & clamp_min_(Tensor & self, Scalar min);
static inline Tensor & clamp_min_out(Tensor & result, const Tensor & self, Scalar min);
static inline bool cudnn_is_acceptable(const Tensor & self);
static inline Tensor constant_pad_nd(const Tensor & self, IntList pad, Scalar value=0);
static inline Tensor convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups);
static inline Tensor _convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled);
static inline Tensor _convolution_nogroup(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding);
static inline std::tuple<Tensor,Tensor,Tensor> _convolution_double_backward(const Tensor & ggI, const Tensor & ggW, const Tensor & ggb, const Tensor & gO, const Tensor & weight, const Tensor & self, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, std::array<bool,3> output_mask);
static inline Tensor conv1d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1, int64_t groups=1);
static inline Tensor conv2d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1, int64_t groups=1);
static inline Tensor conv3d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1, int64_t groups=1);
static inline Tensor conv_tbc(const Tensor & self, const Tensor & weight, const Tensor & bias, int64_t pad=0);
static inline std::tuple<Tensor,Tensor,Tensor> conv_tbc_backward(const Tensor & self, const Tensor & input, const Tensor & weight, const Tensor & bias, int64_t pad);
static inline Tensor conv_transpose1d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, int64_t groups=1, IntList dilation=1);
static inline Tensor conv_transpose2d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, int64_t groups=1, IntList dilation=1);
static inline Tensor conv_transpose3d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, int64_t groups=1, IntList dilation=1);
static inline Tensor & s_copy_(Tensor & self, const Tensor & src, bool non_blocking=false);
static inline Tensor _s_copy_from(const Tensor & self, const Tensor & dst, bool non_blocking=false);
static inline void _copy_same_type_(Tensor & self, const Tensor & src);
static inline Tensor cos(const Tensor & self);
static inline Tensor & cos_(Tensor & self);
static inline Tensor & cos_out(Tensor & result, const Tensor & self);
static inline Tensor cosh(const Tensor & self);
static inline Tensor & cosh_(Tensor & self);
static inline Tensor & cosh_out(Tensor & result, const Tensor & self);
static inline Tensor cosine_embedding_loss(const Tensor & input1, const Tensor & input2, const Tensor & target, double margin=0.0, int64_t reduction=Reduction::Mean);
static inline Tensor cudnn_affine_grid_generator(const Tensor & theta, int64_t N, int64_t C, int64_t H, int64_t W);
static inline Tensor cudnn_affine_grid_generator_backward(const Tensor & grad, int64_t N, int64_t C, int64_t H, int64_t W);
static inline std::tuple<Tensor,Tensor,Tensor> cudnn_batch_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & running_mean, const Tensor & running_var, bool training, double exponential_average_factor, double epsilon);
static inline std::tuple<Tensor,Tensor,Tensor> cudnn_batch_norm_backward(const Tensor & input, const Tensor & grad_output, const Tensor & weight, const Tensor & running_mean, const Tensor & running_var, const Tensor & save_mean, const Tensor & save_var, double epsilon);
static inline Tensor cudnn_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_convolution_backward_input(IntList self_size, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline std::tuple<Tensor,Tensor,Tensor> cudnn_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask);
static inline Tensor cudnn_convolution_backward_bias(const Tensor & grad_output);
static inline Tensor cudnn_convolution_backward_weight(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_convolution_transpose(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline std::tuple<Tensor,Tensor,Tensor> cudnn_convolution_transpose_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask);
static inline Tensor cudnn_convolution_transpose_backward_bias(const Tensor & grad_output);
static inline Tensor cudnn_convolution_transpose_backward_input(const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_convolution_transpose_backward_weight(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_grid_sampler(const Tensor & self, const Tensor & grid);
static inline std::tuple<Tensor,Tensor> cudnn_grid_sampler_backward(const Tensor & self, const Tensor & grid, const Tensor & grad_output);
static inline Tensor cumsum(const Tensor & self, int64_t dim, ScalarType dtype);
static inline Tensor cumsum(const Tensor & self, int64_t dim);
static inline Tensor & cumsum_out(Tensor & result, const Tensor & self, int64_t dim, ScalarType dtype);
static inline Tensor & cumsum_out(Tensor & result, const Tensor & self, int64_t dim);
static inline Tensor cumprod(const Tensor & self, int64_t dim, ScalarType dtype);
static inline Tensor cumprod(const Tensor & self, int64_t dim);
static inline Tensor & cumprod_out(Tensor & result, const Tensor & self, int64_t dim, ScalarType dtype);
static inline Tensor & cumprod_out(Tensor & result, const Tensor & self, int64_t dim);
static inline Tensor ctc_loss(const Tensor & log_probs, const Tensor & targets, IntList input_lengths, IntList target_lengths, int64_t blank=0, int64_t reduction=Reduction::Mean);
static inline Tensor ctc_loss(const Tensor & log_probs, const Tensor & targets, const Tensor & input_lengths, const Tensor & target_lengths, int64_t blank=0, int64_t reduction=Reduction::Mean);
static inline std::tuple<Tensor,Tensor> _ctc_loss(const Tensor & log_probs, const Tensor & targets, IntList input_lengths, IntList target_lengths, int64_t blank=0);
static inline Tensor _ctc_loss_backward(const Tensor & grad, const Tensor & log_probs, const Tensor & targets, IntList input_lengths, IntList target_lengths, const Tensor & neg_log_likelihood, const Tensor & log_alpha, int64_t blank);
static inline Tensor det(const Tensor & self);
static inline Tensor diag_embed(const Tensor & self, int64_t offset=0, int64_t dim1=-2, int64_t dim2=-1);
static inline Tensor diagflat(const Tensor & self, int64_t offset=0);
static inline Tensor diagonal(const Tensor & self, int64_t offset=0, int64_t dim1=0, int64_t dim2=1);
static inline Tensor div(const Tensor & self, const Tensor & other);
static inline Tensor & div_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor div(const Tensor & self, Scalar other);
static inline Tensor dot(const Tensor & self, const Tensor & tensor);
static inline Tensor & dot_out(Tensor & result, const Tensor & self, const Tensor & tensor);
static inline Tensor einsum(std::string equation, TensorList tensors);
static inline Tensor embedding(const Tensor & weight, const Tensor & indices, int64_t padding_idx=-1, bool scale_grad_by_freq=false, bool sparse=false);
static inline Tensor embedding_backward(const Tensor & grad, const Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq, bool sparse);
static inline Tensor embedding_dense_backward(const Tensor & grad, const Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq);
static inline Tensor & embedding_renorm_(Tensor & self, const Tensor & indices, double max_norm, double norm_type);
static inline Tensor embedding_sparse_backward(const Tensor & grad, const Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq);
static inline std::tuple<Tensor,Tensor,Tensor,Tensor> embedding_bag(const Tensor & weight, const Tensor & indices, const Tensor & offsets, bool scale_grad_by_freq=false, int64_t mode=0, bool sparse=false);
static inline std::tuple<Tensor,Tensor,Tensor,Tensor> _embedding_bag(const Tensor & weight, const Tensor & indices, const Tensor & offsets, bool scale_grad_by_freq=false, int64_t mode=0, bool sparse=false);
static inline Tensor _embedding_bag_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, bool sparse);
static inline Tensor _embedding_bag_sparse_backward(const Tensor & grad, const Tensor & indices, const Tensor & offsets, const Tensor & offset2bag, const Tensor & bag_size, int64_t num_weights, bool scale_grad_by_freq, int64_t mode);
static inline 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);
static inline Tensor empty(IntList size, const TensorOptions & options={});
static inline Tensor & empty_out(Tensor & result, IntList size);
static inline Tensor empty_like(const Tensor & self);
static inline Tensor empty_like(const Tensor & self, const TensorOptions & options);
static inline Tensor empty_strided(IntList size, IntList stride, const TensorOptions & options={});
static inline Tensor erf(const Tensor & self);
static inline Tensor & erf_(Tensor & self);
static inline Tensor & erf_out(Tensor & result, const Tensor & self);
static inline Tensor erfc(const Tensor & self);
static inline Tensor & erfc_(Tensor & self);
static inline Tensor & erfc_out(Tensor & result, const Tensor & self);
static inline Tensor exp(const Tensor & self);
static inline Tensor & exp_(Tensor & self);
static inline Tensor & exp_out(Tensor & result, const Tensor & self);
static inline Tensor expm1(const Tensor & self);
static inline Tensor & expm1_(Tensor & self);
static inline Tensor & expm1_out(Tensor & result, const Tensor & self);
static inline Tensor eye(int64_t n, const TensorOptions & options={});
static inline Tensor eye(int64_t n, int64_t m, const TensorOptions & options={});
static inline Tensor & eye_out(Tensor & result, int64_t n);
static inline Tensor & eye_out(Tensor & result, int64_t n, int64_t m);
static inline Tensor flatten(const Tensor & self, int64_t start_dim=0, int64_t end_dim=-1);
static inline Tensor & fill_(Tensor & self, Scalar value);
static inline Tensor & fill_(Tensor & self, const Tensor & value);
static inline Tensor floor(const Tensor & self);
static inline Tensor & floor_(Tensor & self);
static inline Tensor & floor_out(Tensor & result, const Tensor & self);
static inline Tensor full(IntList size, Scalar fill_value, const TensorOptions & options={});
static inline Tensor & full_out(Tensor & result, IntList size, Scalar fill_value);
static inline Tensor full_like(const Tensor & self, Scalar fill_value);
static inline Tensor full_like(const Tensor & self, Scalar fill_value, const TensorOptions & options);
static inline Tensor grid_sampler(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode);
static inline Tensor grid_sampler_2d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode);
static inline 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);
static inline Tensor grid_sampler_3d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode);
static inline 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);
static inline Tensor hann_window(int64_t window_length, const TensorOptions & options={});
static inline Tensor hann_window(int64_t window_length, bool periodic, const TensorOptions & options={});
static inline Tensor hamming_window(int64_t window_length, const TensorOptions & options={});
static inline Tensor hamming_window(int64_t window_length, bool periodic, const TensorOptions & options={});
static inline Tensor hamming_window(int64_t window_length, bool periodic, double alpha, const TensorOptions & options={});
static inline Tensor hamming_window(int64_t window_length, bool periodic, double alpha, double beta, const TensorOptions & options={});
static inline Tensor hinge_embedding_loss(const Tensor & self, const Tensor & target, double margin=1.0, int64_t reduction=Reduction::Mean);
static inline Tensor ger(const Tensor & self, const Tensor & vec2);
static inline Tensor & ger_out(Tensor & result, const Tensor & self, const Tensor & vec2);
static inline std::tuple<Tensor,Tensor> gesv(const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor &,Tensor &> gesv_out(Tensor & solution, Tensor & lu, const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor,Tensor> _gesv_helper(const Tensor & self, const Tensor & A);
static inline Tensor group_norm(const Tensor & input, int64_t num_groups, const Tensor & weight={}, const Tensor & bias={}, double eps=1e-05, bool cudnn_enabled=true);
static inline Tensor fft(const Tensor & self, int64_t signal_ndim, bool normalized=false);
static inline Tensor ifft(const Tensor & self, int64_t signal_ndim, bool normalized=false);
static inline Tensor rfft(const Tensor & self, int64_t signal_ndim, bool normalized=false, bool onesided=true);
static inline Tensor irfft(const Tensor & self, int64_t signal_ndim, bool normalized=false, bool onesided=true, IntList signal_sizes={});
static inline Tensor _fft_with_size(const Tensor & self, int64_t signal_ndim, bool complex_input, bool complex_output, bool inverse, IntList checked_signal_sizes, bool normalized, bool onesided, IntList output_sizes);
static inline int64_t _cufft_get_plan_cache_size();
static inline int64_t _cufft_get_plan_cache_max_size();
static inline void _cufft_set_plan_cache_max_size(int64_t max_size);
static inline void _cufft_clear_plan_cache();
static inline Tensor index(const Tensor & self, TensorList indices);
static inline Tensor index_put(const Tensor & self, TensorList indices, const Tensor & values, bool accumulate=false);
static inline Tensor & index_put_(Tensor & self, TensorList indices, const Tensor & values, bool accumulate=false);
static inline Tensor instance_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & running_mean, const Tensor & running_var, bool use_input_stats, double momentum, double eps, bool cudnn_enabled);
static inline Tensor inverse(const Tensor & self);
static inline Tensor & inverse_out(Tensor & result, const Tensor & self);
static inline Tensor _inverse_helper(const Tensor & self);
static inline Tensor isclose(const Tensor & self, const Tensor & other, double rtol=1e-05, double atol=1e-08, bool equal_nan=false);
static inline bool is_distributed(const Tensor & self);
static inline bool is_floating_point(const Tensor & self);
static inline bool is_complex(const Tensor & self);
static inline bool is_nonzero(const Tensor & self);
static inline bool is_same_size(const Tensor & self, const Tensor & other);
static inline bool is_signed(const Tensor & self);
static inline Tensor kl_div(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor kl_div_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline std::tuple<Tensor,Tensor> kthvalue(const Tensor & self, int64_t k, int64_t dim=-1, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> kthvalue_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim=-1, bool keepdim=false);
static inline Tensor layer_norm(const Tensor & input, IntList normalized_shape, const Tensor & weight={}, const Tensor & bias={}, double eps=1e-05, bool cudnn_enable=true);
static inline Tensor linear(const Tensor & input, const Tensor & weight, const Tensor & bias={});
static inline Tensor linspace(Scalar start, Scalar end, const TensorOptions & options={});
static inline Tensor linspace(Scalar start, Scalar end, int64_t steps, const TensorOptions & options={});
static inline Tensor & linspace_out(Tensor & result, Scalar start, Scalar end);
static inline Tensor & linspace_out(Tensor & result, Scalar start, Scalar end, int64_t steps);
static inline Tensor log(const Tensor & self);
static inline Tensor & log_(Tensor & self);
static inline Tensor & log_out(Tensor & result, const Tensor & self);
static inline Tensor log10(const Tensor & self);
static inline Tensor & log10_(Tensor & self);
static inline Tensor & log10_out(Tensor & result, const Tensor & self);
static inline Tensor log1p(const Tensor & self);
static inline Tensor & log1p_(Tensor & self);
static inline Tensor & log1p_out(Tensor & result, const Tensor & self);
static inline Tensor log2(const Tensor & self);
static inline Tensor & log2_(Tensor & self);
static inline Tensor & log2_out(Tensor & result, const Tensor & self);
static inline Tensor logdet(const Tensor & self);
static inline Tensor logspace(Scalar start, Scalar end, const TensorOptions & options={});
static inline Tensor logspace(Scalar start, Scalar end, int64_t steps, const TensorOptions & options={});
static inline Tensor & logspace_out(Tensor & result, Scalar start, Scalar end);
static inline Tensor & logspace_out(Tensor & result, Scalar start, Scalar end, int64_t steps);
static inline Tensor log_softmax(const Tensor & self, int64_t dim, ScalarType dtype);
static inline Tensor log_softmax(const Tensor & self, int64_t dim);
static inline Tensor _log_softmax(const Tensor & self, int64_t dim, bool half_to_float);
static inline Tensor _log_softmax_backward_data(const Tensor & grad_output, const Tensor & output, int64_t dim, const Tensor & self);
static inline Tensor logsumexp(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor & logsumexp_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor margin_ranking_loss(const Tensor & input1, const Tensor & input2, const Tensor & target, double margin=0.0, int64_t reduction=Reduction::Mean);
static inline Tensor matmul(const Tensor & self, const Tensor & other);
static inline Tensor & matmul_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor matrix_rank(const Tensor & self, double tol, bool symmetric=false);
static inline Tensor matrix_rank(const Tensor & self, bool symmetric=false);
static inline Tensor matrix_power(const Tensor & self, int64_t n);
static inline std::tuple<Tensor,Tensor> max(const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> max_out(Tensor & max, Tensor & max_values, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor max_values(const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> max_pool1d_with_indices(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline Tensor max_pool1d(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline Tensor max_pool2d(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline Tensor max_pool3d(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline Tensor mean(const Tensor & self, ScalarType dtype);
static inline Tensor mean(const Tensor & self);
static inline Tensor mean(const Tensor & self, IntList dim, bool keepdim, ScalarType dtype);
static inline Tensor mean(const Tensor & self, IntList dim, bool keepdim=false);
static inline Tensor mean(const Tensor & self, IntList dim, ScalarType dtype);
static inline Tensor & mean_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim, ScalarType dtype);
static inline Tensor & mean_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim=false);
static inline Tensor & mean_out(Tensor & result, const Tensor & self, IntList dim, ScalarType dtype);
static inline std::tuple<Tensor,Tensor> median(const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> median_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> min(const Tensor & self, int64_t dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> min_out(Tensor & min, Tensor & min_indices, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor min_values(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor mkldnn_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList stride, IntList dilation, int64_t groups);
static inline Tensor mkldnn_convolution_backward_input(IntList self_size, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool bias_defined);
static inline std::tuple<Tensor,Tensor> mkldnn_convolution_backward_weights(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool bias_defined);
static inline std::tuple<Tensor,Tensor,Tensor> mkldnn_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, std::array<bool,3> output_mask);
static inline std::tuple<Tensor,Tensor,Tensor> miopen_batch_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & running_mean, const Tensor & running_var, bool training, double exponential_average_factor, double epsilon);
static inline std::tuple<Tensor,Tensor,Tensor> miopen_batch_norm_backward(const Tensor & input, const Tensor & grad_output, const Tensor & weight, const Tensor & running_mean, const Tensor & running_var, const Tensor & save_mean, const Tensor & save_var, double epsilon);
static inline Tensor miopen_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor miopen_convolution_backward_input(IntList self_size, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline std::tuple<Tensor,Tensor,Tensor> miopen_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask);
static inline Tensor miopen_convolution_backward_bias(const Tensor & grad_output);
static inline Tensor miopen_convolution_backward_weight(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor miopen_convolution_transpose(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline std::tuple<Tensor,Tensor,Tensor> miopen_convolution_transpose_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask);
static inline Tensor miopen_convolution_transpose_backward_input(const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor miopen_convolution_transpose_backward_weight(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor mm(const Tensor & self, const Tensor & mat2);
static inline Tensor & mm_out(Tensor & result, const Tensor & self, const Tensor & mat2);
static inline Tensor _sparse_mm(const Tensor & sparse, const Tensor & dense);
static inline std::tuple<Tensor,Tensor> mode(const Tensor & self, int64_t dim=-1, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> mode_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim=-1, bool keepdim=false);
static inline Tensor mul(const Tensor & self, const Tensor & other);
static inline Tensor & mul_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor mul(const Tensor & self, Scalar other);
static inline Tensor mv(const Tensor & self, const Tensor & vec);
static inline Tensor & mv_out(Tensor & result, const Tensor & self, const Tensor & vec);
static inline Tensor mvlgamma(const Tensor & self, int64_t p);
static inline Tensor narrow(const Tensor & self, int64_t dim, int64_t start, int64_t length);
static inline 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);
static inline 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);
static inline Tensor ones(IntList size, const TensorOptions & options={});
static inline Tensor & ones_out(Tensor & result, IntList size);
static inline Tensor ones_like(const Tensor & self);
static inline Tensor ones_like(const Tensor & self, const TensorOptions & options);
static inline Tensor pairwise_distance(const Tensor & x1, const Tensor & x2, double p=2, double eps=1e-06, bool keepdim=false);
static inline Tensor pdist(const Tensor & self, double p=2);
static inline Tensor _pdist_forward(const Tensor & self, double p=2);
static inline Tensor _pdist_backward(const Tensor & grad, const Tensor & self, double p, const Tensor & pdist);
static inline Tensor cosine_similarity(const Tensor & x1, const Tensor & x2, int64_t dim=1, double eps=1e-08);
static inline Tensor pixel_shuffle(const Tensor & self, int64_t upscale_factor);
static inline Tensor pin_memory(const Tensor & self);
static inline Tensor pinverse(const Tensor & self, double rcond=1e-15);
static inline Tensor rand(IntList size, const TensorOptions & options={});
static inline Tensor rand(IntList size, Generator * generator, const TensorOptions & options={});
static inline Tensor & rand_out(Tensor & result, IntList size);
static inline Tensor & rand_out(Tensor & result, IntList size, Generator * generator);
static inline Tensor rand_like(const Tensor & self);
static inline Tensor rand_like(const Tensor & self, const TensorOptions & options);
static inline Tensor randint(int64_t high, IntList size, const TensorOptions & options={});
static inline Tensor randint(int64_t high, IntList size, Generator * generator, const TensorOptions & options={});
static inline Tensor randint(int64_t low, int64_t high, IntList size, const TensorOptions & options={});
static inline Tensor randint(int64_t low, int64_t high, IntList size, Generator * generator, const TensorOptions & options={});
static inline Tensor & randint_out(Tensor & result, int64_t high, IntList size);
static inline Tensor & randint_out(Tensor & result, int64_t high, IntList size, Generator * generator);
static inline Tensor & randint_out(Tensor & result, int64_t low, int64_t high, IntList size);
static inline Tensor & randint_out(Tensor & result, int64_t low, int64_t high, IntList size, Generator * generator);
static inline Tensor randint_like(const Tensor & self, int64_t high);
static inline Tensor randint_like(const Tensor & self, int64_t low, int64_t high);
static inline Tensor randint_like(const Tensor & self, int64_t high, const TensorOptions & options);
static inline Tensor randint_like(const Tensor & self, int64_t low, int64_t high, const TensorOptions & options);
static inline Tensor randn(IntList size, const TensorOptions & options={});
static inline Tensor randn(IntList size, Generator * generator, const TensorOptions & options={});
static inline Tensor & randn_out(Tensor & result, IntList size);
static inline Tensor & randn_out(Tensor & result, IntList size, Generator * generator);
static inline Tensor randn_like(const Tensor & self);
static inline Tensor randn_like(const Tensor & self, const TensorOptions & options);
static inline Tensor randperm(int64_t n, const TensorOptions & options={});
static inline Tensor randperm(int64_t n, Generator * generator, const TensorOptions & options={});
static inline Tensor & randperm_out(Tensor & result, int64_t n);
static inline Tensor & randperm_out(Tensor & result, int64_t n, Generator * generator);
static inline Tensor range(Scalar start, Scalar end, const TensorOptions & options={});
static inline Tensor range(Scalar start, Scalar end, Scalar step, const TensorOptions & options={});
static inline Tensor & range_out(Tensor & result, Scalar start, Scalar end);
static inline Tensor & range_out(Tensor & result, Scalar start, Scalar end, Scalar step);
static inline Tensor reshape(const Tensor & self, IntList shape);
static inline std::tuple<Tensor,Tensor> RoiPooling2d_forward(const Tensor & input, const Tensor & rois, int64_t pooledHeight, int64_t pooledWidth, double spatialScale);
static inline Tensor RoiPooling2d_backward(const Tensor & input, const Tensor & rois, int64_t pooledHeight, int64_t pooledWidth, double spatialScale, const Tensor & gradOutput, const Tensor & argmaxes);
static inline Tensor round(const Tensor & self);
static inline Tensor & round_(Tensor & self);
static inline Tensor & round_out(Tensor & result, const Tensor & self);
static inline Tensor rrelu(const Tensor & self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator * generator=nullptr);
static inline Tensor & rrelu_(Tensor & self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator * generator=nullptr);
static inline Tensor relu(const Tensor & self);
static inline Tensor & relu_(Tensor & self);
static inline Tensor prelu(const Tensor & self, const Tensor & weight);
static inline std::tuple<Tensor,Tensor> prelu_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight);
static inline Tensor hardshrink(const Tensor & self, Scalar lambd=0.5);
static inline Tensor hardshrink_backward(const Tensor & grad_out, const Tensor & self, Scalar lambd);
static inline Tensor rsqrt(const Tensor & self);
static inline Tensor & rsqrt_(Tensor & self);
static inline Tensor & rsqrt_out(Tensor & result, const Tensor & self);
static inline Tensor select(const Tensor & self, int64_t dim, int64_t index);
static inline Tensor selu(const Tensor & self);
static inline Tensor & selu_(Tensor & self);
static inline Tensor celu(const Tensor & self, Scalar alpha=1.0);
static inline Tensor & celu_(Tensor & self, Scalar alpha=1.0);
static inline Tensor sigmoid(const Tensor & self);
static inline Tensor & sigmoid_(Tensor & self);
static inline Tensor & sigmoid_out(Tensor & result, const Tensor & self);
static inline Tensor sin(const Tensor & self);
static inline Tensor & sin_(Tensor & self);
static inline Tensor & sin_out(Tensor & result, const Tensor & self);
static inline Tensor sinh(const Tensor & self);
static inline Tensor & sinh_(Tensor & self);
static inline Tensor & sinh_out(Tensor & result, const Tensor & self);
static inline Tensor detach(const Tensor & self);
static inline Tensor & detach_(Tensor & self);
static inline int64_t size(const Tensor & self, int64_t dim);
static inline Tensor slice(const Tensor & self, int64_t dim=0, int64_t start=0, int64_t end=9223372036854775807, int64_t step=1);
static inline std::tuple<Tensor,Tensor> slogdet(const Tensor & self);
static inline Tensor smm(const Tensor & self, const Tensor & mat2);
static inline Tensor softmax(const Tensor & self, int64_t dim, ScalarType dtype);
static inline Tensor softmax(const Tensor & self, int64_t dim);
static inline Tensor _softmax(const Tensor & self, int64_t dim, bool half_to_float);
static inline Tensor _softmax_backward_data(const Tensor & grad_output, const Tensor & output, int64_t dim, const Tensor & self);
static inline Tensor & _sparse_add_out(Tensor & result, const Tensor & self, const Tensor & other, Scalar alpha=1);
static inline Tensor & _sparse_dense_add_out(Tensor & result, const Tensor & self, SparseTensorRef other, Scalar alpha=1);
static inline Tensor & _sparse_div_zerodim_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor & _sparse_div_scalar_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor & _sparse_mul_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor & _sparse_mul_zerodim_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor & _sparse_mul_scalar_out(Tensor & result, const Tensor & self, Scalar other);
static inline std::vector<Tensor> split(const Tensor & self, int64_t split_size, int64_t dim=0);
static inline std::vector<Tensor> split_with_sizes(const Tensor & self, IntList split_sizes, int64_t dim=0);
static inline Tensor squeeze(const Tensor & self);
static inline Tensor squeeze(const Tensor & self, int64_t dim);
static inline Tensor sspaddmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & sspaddmm_out(Tensor & result, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor stack(TensorList tensors, int64_t dim=0);
static inline Tensor & stack_out(Tensor & result, TensorList tensors, int64_t dim=0);
static inline Tensor stft(const Tensor & self, int64_t n_fft, int64_t hop_length, int64_t win_length, const Tensor & window={}, bool normalized=false, bool onesided=true);
static inline int64_t stride(const Tensor & self, int64_t dim);
static inline Tensor sum(const Tensor & self, ScalarType dtype);
static inline Tensor sum(const Tensor & self);
static inline Tensor sum(const Tensor & self, IntList dim, bool keepdim, ScalarType dtype);
static inline Tensor sum(const Tensor & self, IntList dim, bool keepdim=false);
static inline Tensor sum(const Tensor & self, IntList dim, ScalarType dtype);
static inline Tensor & sum_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim, ScalarType dtype);
static inline Tensor & sum_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim=false);
static inline Tensor & sum_out(Tensor & result, const Tensor & self, IntList dim, ScalarType dtype);
static inline Tensor sqrt(const Tensor & self);
static inline Tensor & sqrt_(Tensor & self);
static inline Tensor & sqrt_out(Tensor & result, const Tensor & self);
static inline Tensor std(const Tensor & self, bool unbiased=true);
static inline Tensor std(const Tensor & self, int64_t dim, bool unbiased=true, bool keepdim=false);
static inline Tensor & std_out(Tensor & result, const Tensor & self, int64_t dim, bool unbiased=true, bool keepdim=false);
static inline Tensor prod(const Tensor & self, ScalarType dtype);
static inline Tensor prod(const Tensor & self);
static inline Tensor prod(const Tensor & self, int64_t dim, bool keepdim, ScalarType dtype);
static inline Tensor prod(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor prod(const Tensor & self, int64_t dim, ScalarType dtype);
static inline Tensor & prod_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim, ScalarType dtype);
static inline Tensor & prod_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor & prod_out(Tensor & result, const Tensor & self, int64_t dim, ScalarType dtype);
static inline Tensor t(const Tensor & self);
static inline Tensor tan(const Tensor & self);
static inline Tensor & tan_(Tensor & self);
static inline Tensor & tan_out(Tensor & result, const Tensor & self);
static inline Tensor tanh(const Tensor & self);
static inline Tensor & tanh_(Tensor & self);
static inline Tensor & tanh_out(Tensor & result, const Tensor & self);
static inline Tensor tensordot(const Tensor & self, const Tensor & other, IntList dims_self, IntList dims_other);
static inline Tensor threshold(const Tensor & self, Scalar threshold, Scalar value);
static inline Tensor & threshold_(Tensor & self, Scalar threshold, Scalar value);
static inline Tensor & threshold_out(Tensor & result, const Tensor & self, Scalar threshold, Scalar value);
static inline Tensor threshold_backward(const Tensor & grad_output, const Tensor & self, Scalar threshold);
static inline Tensor transpose(const Tensor & self, int64_t dim0, int64_t dim1);
static inline Tensor flip(const Tensor & self, IntList dims);
static inline Tensor roll(const Tensor & self, IntList shifts, IntList dims={});
static inline Tensor rot90(const Tensor & self, int64_t k=1, IntList dims={0,1});
static inline Tensor _trilinear(const Tensor & i1, const Tensor & i2, const Tensor & i3, IntList expand1, IntList expand2, IntList expand3, IntList sumdim, int64_t unroll_dim=1);
static inline Tensor triplet_margin_loss(const Tensor & anchor, const Tensor & positive, const Tensor & negative, double margin=1.0, double p=2, double eps=1e-06, bool swap=false, int64_t reduction=Reduction::Mean);
static inline Tensor trunc(const Tensor & self);
static inline Tensor & trunc_(Tensor & self);
static inline Tensor & trunc_out(Tensor & result, const Tensor & self);
static inline std::tuple<Tensor,Tensor> _unique(const Tensor & self, bool sorted=false, bool return_inverse=false);
static inline std::tuple<Tensor,Tensor> _unique_dim(const Tensor & self, int64_t dim, bool sorted=false, bool return_inverse=false);
static inline Tensor _unsafe_view(const Tensor & self, IntList size);
static inline Tensor unsqueeze(const Tensor & self, int64_t dim);
static inline Tensor var(const Tensor & self, bool unbiased=true);
static inline Tensor var(const Tensor & self, int64_t dim, bool unbiased=true, bool keepdim=false);
static inline Tensor & var_out(Tensor & result, const Tensor & self, int64_t dim, bool unbiased=true, bool keepdim=false);
static inline Tensor where(const Tensor & condition, const Tensor & self, const Tensor & other);
static inline Tensor _s_where(const Tensor & condition, const Tensor & self, const Tensor & other);
static inline Tensor norm_except_dim(const Tensor & v, int64_t pow=2, int64_t dim=0);
static inline Tensor _weight_norm(const Tensor & v, const Tensor & g, int64_t dim=0);
static inline std::tuple<Tensor,Tensor> _weight_norm_cuda_interface(const Tensor & v, const Tensor & g, int64_t dim=0);
static inline std::tuple<Tensor,Tensor> _weight_norm_cuda_interface_backward(const Tensor & grad_w, const Tensor & saved_v, const Tensor & saved_g, const Tensor & saved_norms, int64_t dim);
static inline std::tuple<Tensor,Tensor> _weight_norm_differentiable_backward(const Tensor & grad_w, const Tensor & saved_v, const Tensor & saved_g, const Tensor & saved_norms, int64_t dim);
static inline Tensor zeros(IntList size, const TensorOptions & options={});
static inline Tensor & zeros_out(Tensor & result, IntList size);
static inline Tensor zeros_like(const Tensor & self);
static inline Tensor zeros_like(const Tensor & self, const TensorOptions & options);
static inline Tensor _standard_gamma_grad(const Tensor & self, const Tensor & output);
static inline Tensor _standard_gamma(const Tensor & self, Generator * generator=nullptr);
static inline Tensor poisson(const Tensor & self, Generator * generator=nullptr);
static inline Tensor native_norm(const Tensor & self, Scalar p=2);
static inline Tensor _sparse_sum(const Tensor & self);
static inline Tensor _sparse_sum(const Tensor & self, ScalarType dtype);
static inline Tensor _sparse_sum(const Tensor & self, IntList dim);
static inline Tensor _sparse_sum(const Tensor & self, IntList dim, ScalarType dtype);
static inline Tensor _sparse_sum_backward(const Tensor & grad, const Tensor & self, IntList dim);
static inline Tensor norm(const Tensor & self, Scalar p=2);
static inline Tensor norm(const Tensor & self, Scalar p, int64_t dim, bool keepdim=false);
static inline Tensor & norm_out(Tensor & result, const Tensor & self, Scalar p, int64_t dim, bool keepdim=false);
static inline Tensor frobenius_norm(const Tensor & self);
static inline Tensor frobenius_norm(const Tensor & self, IntList dim, bool keepdim=false);
static inline Tensor & frobenius_norm_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim=false);
static inline Tensor nuclear_norm(const Tensor & self, bool keepdim=false);
static inline Tensor & nuclear_norm_out(Tensor & result, const Tensor & self, bool keepdim=false);
static inline Tensor native_clone(const Tensor & self);
static inline Tensor clone(const Tensor & self);
static inline Tensor & native_resize_as_(Tensor & self, const Tensor & the_template);
static inline Tensor & resize_as_(Tensor & self, const Tensor & the_template);
static inline Tensor & native_pow_out(Tensor & result, const Tensor & self, Scalar exponent);
static inline Tensor native_pow(const Tensor & self, Scalar exponent);
static inline Tensor & pow_out(Tensor & result, const Tensor & self, Scalar exponent);
static inline Tensor pow(const Tensor & self, Scalar exponent);
static inline Tensor & native_zero_(Tensor & self);
static inline Tensor & zero_(Tensor & self);
static inline Tensor & sub_out(Tensor & result, const Tensor & self, const Tensor & other, Scalar alpha=1);
static inline Tensor sub(const Tensor & self, const Tensor & other, Scalar alpha=1);
static inline Tensor sub(const Tensor & self, Scalar other, Scalar alpha=1);
static inline Tensor rsub(const Tensor & self, const Tensor & other, Scalar alpha=1);
static inline Tensor rsub(const Tensor & self, Scalar other, Scalar alpha=1);
static inline Tensor & s_native_addmm_out(Tensor & result, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor s_native_addmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & s_native_addmm_(Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor _sparse_addmm(const Tensor & self, const Tensor & sparse, const Tensor & dense, Scalar beta=1, Scalar alpha=1);
static inline Tensor & addmm_out(Tensor & result, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor addmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta=1, Scalar alpha=1);
static inline Tensor sparse_coo_tensor(IntList size, const TensorOptions & options);
static inline Tensor sparse_coo_tensor(const Tensor & indices, const Tensor & values, const TensorOptions & options={});
static inline Tensor sparse_coo_tensor(const Tensor & indices, const Tensor & values, IntList size, const TensorOptions & options={});
static inline Tensor _sparse_coo_tensor_unsafe(const Tensor & indices, const Tensor & values, IntList size, const TensorOptions & options={});
static inline Tensor _sparse_coo_tensor_with_dims(int64_t sparse_dim, int64_t dense_dim, IntList size, const TensorOptions & options);
static inline Tensor _sparse_coo_tensor_with_dims_and_tensors(int64_t sparse_dim, int64_t dense_dim, IntList size, const Tensor & indices, const Tensor & values, const TensorOptions & options);
static inline Tensor & hspmm_out(Tensor & result, const Tensor & mat1, const Tensor & mat2);
static inline Tensor hspmm(const Tensor & mat1, const Tensor & mat2);
static inline Tensor & copy_sparse_to_sparse_(Tensor & self, const Tensor & src, bool non_blocking=false);
static inline int64_t numel(const Tensor & self);
static inline std::vector<Tensor> unbind(const Tensor & self, int64_t dim=0);
static inline std::vector<Tensor> meshgrid(TensorList tensors);
static inline Scalar _local_scalar_dense(const Tensor & self);
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_fused_lstm_cell(const Tensor & input_gates, const Tensor & hidden_gates, const Tensor & cx, const Tensor & input_bias={}, const Tensor & hidden_bias={});
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_fused_lstm_cell_backward(const Tensor & grad_hy, const Tensor & grad_cy, const Tensor & cx, const Tensor & cy, const Tensor & workspace, bool has_bias);
static inline std::tuple<Tensor,Tensor> _thnn_fused_gru_cell(const Tensor & input_gates, const Tensor & hidden_gates, const Tensor & hx, const Tensor & input_bias={}, const Tensor & hidden_bias={});
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_fused_gru_cell_backward(const Tensor & grad_hy, const Tensor & workspace, bool has_bias);
static inline std::tuple<Tensor,Tensor,Tensor> lstm(const Tensor & input, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first);
static inline std::tuple<Tensor,Tensor,Tensor> lstm(const Tensor & data, const Tensor & batch_sizes, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional);
static inline std::tuple<Tensor,Tensor> gru(const Tensor & input, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first);
static inline std::tuple<Tensor,Tensor> gru(const Tensor & data, const Tensor & batch_sizes, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional);
static inline std::tuple<Tensor,Tensor> rnn_tanh(const Tensor & input, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first);
static inline std::tuple<Tensor,Tensor> rnn_tanh(const Tensor & data, const Tensor & batch_sizes, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional);
static inline std::tuple<Tensor,Tensor> rnn_relu(const Tensor & input, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first);
static inline std::tuple<Tensor,Tensor> rnn_relu(const Tensor & data, const Tensor & batch_sizes, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional);
static inline std::tuple<Tensor,Tensor> lstm_cell(const Tensor & input, TensorList hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih={}, const Tensor & b_hh={});
static inline Tensor gru_cell(const Tensor & input, const Tensor & hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih={}, const Tensor & b_hh={});
static inline Tensor rnn_tanh_cell(const Tensor & input, const Tensor & hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih={}, const Tensor & b_hh={});
static inline Tensor rnn_relu_cell(const Tensor & input, const Tensor & hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih={}, const Tensor & b_hh={});
static inline std::tuple<Tensor,Tensor> _pack_padded_sequence(const Tensor & input, const Tensor & lengths, bool batch_first);
static inline Tensor _pack_padded_sequence_backward(const Tensor & grad, IntList input_size, const Tensor & batch_sizes, bool batch_first);
static inline std::tuple<Tensor,Tensor> _pad_packed_sequence(const Tensor & data, const Tensor & batch_sizes, bool batch_first, Scalar padding_value, int64_t total_length);
static inline Tensor __and__(const Tensor & self, Scalar other);
static inline Tensor __and__(const Tensor & self, const Tensor & other);
static inline Tensor __or__(const Tensor & self, Scalar other);
static inline Tensor __or__(const Tensor & self, const Tensor & other);
static inline Tensor __xor__(const Tensor & self, Scalar other);
static inline Tensor __xor__(const Tensor & self, const Tensor & other);
static inline Tensor __lshift__(const Tensor & self, Scalar other);
static inline Tensor __lshift__(const Tensor & self, const Tensor & other);
static inline Tensor __rshift__(const Tensor & self, Scalar other);
static inline Tensor __rshift__(const Tensor & self, const Tensor & other);
static inline Tensor & addbmm_out(Tensor & result, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor addbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & diag_out(Tensor & result, const Tensor & self, int64_t diagonal=0);
static inline Tensor diag(const Tensor & self, int64_t diagonal=0);
static inline Tensor & cross_out(Tensor & result, const Tensor & self, const Tensor & other, int64_t dim=-1);
static inline Tensor cross(const Tensor & self, const Tensor & other, int64_t dim=-1);
static inline Tensor & triu_out(Tensor & result, const Tensor & self, int64_t diagonal=0);
static inline Tensor triu(const Tensor & self, int64_t diagonal=0);
static inline Tensor & tril_out(Tensor & result, const Tensor & self, int64_t diagonal=0);
static inline Tensor tril(const Tensor & self, int64_t diagonal=0);
static inline Tensor trace(const Tensor & self);
static inline Tensor & ne_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor ne(const Tensor & self, Scalar other);
static inline Tensor & ne_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor ne(const Tensor & self, const Tensor & other);
static inline Tensor & eq_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor eq(const Tensor & self, Scalar other);
static inline Tensor & eq_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor eq(const Tensor & self, const Tensor & other);
static inline Tensor & ge_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor ge(const Tensor & self, Scalar other);
static inline Tensor & ge_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor ge(const Tensor & self, const Tensor & other);
static inline Tensor & le_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor le(const Tensor & self, Scalar other);
static inline Tensor & le_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor le(const Tensor & self, const Tensor & other);
static inline Tensor & gt_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor gt(const Tensor & self, Scalar other);
static inline Tensor & gt_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor gt(const Tensor & self, const Tensor & other);
static inline Tensor & lt_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor lt(const Tensor & self, Scalar other);
static inline Tensor & lt_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor lt(const Tensor & self, const Tensor & other);
static inline Tensor & take_out(Tensor & result, const Tensor & self, const Tensor & index);
static inline Tensor take(const Tensor & self, const Tensor & index);
static inline Tensor & index_select_out(Tensor & result, const Tensor & self, int64_t dim, const Tensor & index);
static inline Tensor index_select(const Tensor & self, int64_t dim, const Tensor & index);
static inline Tensor & masked_select_out(Tensor & result, const Tensor & self, const Tensor & mask);
static inline Tensor masked_select(const Tensor & self, const Tensor & mask);
static inline Tensor & nonzero_out(Tensor & result, const Tensor & self);
static inline Tensor nonzero(const Tensor & self);
static inline Tensor & gather_out(Tensor & result, const Tensor & self, int64_t dim, const Tensor & index);
static inline Tensor gather(const Tensor & self, int64_t dim, const Tensor & index);
static inline Tensor & addcmul_out(Tensor & result, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline Tensor addcmul(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline Tensor & addcdiv_out(Tensor & result, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline Tensor addcdiv(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value=1);
static inline std::tuple<Tensor &,Tensor &> gels_out(Tensor & X, Tensor & qr, const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor,Tensor> gels(const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor &,Tensor &> trtrs_out(Tensor & X, Tensor & M, const Tensor & self, const Tensor & A, bool upper=true, bool transpose=false, bool unitriangular=false);
static inline std::tuple<Tensor,Tensor> trtrs(const Tensor & self, const Tensor & A, bool upper=true, bool transpose=false, bool unitriangular=false);
static inline std::tuple<Tensor &,Tensor &> symeig_out(Tensor & e, Tensor & V, const Tensor & self, bool eigenvectors=false, bool upper=true);
static inline std::tuple<Tensor,Tensor> symeig(const Tensor & self, bool eigenvectors=false, bool upper=true);
static inline std::tuple<Tensor &,Tensor &> eig_out(Tensor & e, Tensor & v, const Tensor & self, bool eigenvectors=false);
static inline std::tuple<Tensor,Tensor> eig(const Tensor & self, bool eigenvectors=false);
static inline std::tuple<Tensor &,Tensor &,Tensor &> svd_out(Tensor & U, Tensor & S, Tensor & V, const Tensor & self, bool some=true, bool compute_uv=true);
static inline std::tuple<Tensor,Tensor,Tensor> svd(const Tensor & self, bool some=true, bool compute_uv=true);
static inline Tensor & cholesky_out(Tensor & result, const Tensor & self, bool upper=false);
static inline Tensor cholesky(const Tensor & self, bool upper=false);
static inline Tensor _cholesky_helper(const Tensor & self, bool upper);
static inline Tensor & potrs_out(Tensor & result, const Tensor & self, const Tensor & input2, bool upper=true);
static inline Tensor potrs(const Tensor & self, const Tensor & input2, bool upper=true);
static inline Tensor _potrs_helper(const Tensor & self, const Tensor & A, bool upper);
static inline Tensor & potri_out(Tensor & result, const Tensor & self, bool upper=true);
static inline Tensor potri(const Tensor & self, bool upper=true);
static inline std::tuple<Tensor &,Tensor &> pstrf_out(Tensor & u, Tensor & piv, const Tensor & self, bool upper=true, Scalar tol=-1);
static inline std::tuple<Tensor,Tensor> pstrf(const Tensor & self, bool upper=true, Scalar tol=-1);
static inline std::tuple<Tensor &,Tensor &> qr_out(Tensor & Q, Tensor & R, const Tensor & self);
static inline std::tuple<Tensor,Tensor> qr(const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> geqrf_out(Tensor & result0, Tensor & result1, const Tensor & self);
static inline std::tuple<Tensor,Tensor> geqrf(const Tensor & self);
static inline Tensor & orgqr_out(Tensor & result, const Tensor & self, const Tensor & input2);
static inline Tensor orgqr(const Tensor & self, const Tensor & input2);
static inline Tensor & ormqr_out(Tensor & result, const Tensor & self, const Tensor & input2, const Tensor & input3, bool left=true, bool transpose=false);
static inline Tensor ormqr(const Tensor & self, const Tensor & input2, const Tensor & input3, bool left=true, bool transpose=false);
static inline std::tuple<Tensor &,Tensor &> btrifact_out(Tensor & A_LU, Tensor & pivots, const Tensor & self, bool pivot=true);
static inline std::tuple<Tensor,Tensor> btrifact(const Tensor & self, bool pivot=true);
static inline std::tuple<Tensor &,Tensor &,Tensor &> btrifact_with_info_out(Tensor & A_LU, Tensor & pivots, Tensor & info, const Tensor & self, bool pivot=true);
static inline std::tuple<Tensor,Tensor,Tensor> btrifact_with_info(const Tensor & self, bool pivot=true);
static inline Tensor & btrisolve_out(Tensor & result, const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots);
static inline Tensor btrisolve(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots);
static inline Tensor & multinomial_out(Tensor & result, const Tensor & self, int64_t num_samples, bool replacement=false, Generator * generator=nullptr);
static inline Tensor multinomial(const Tensor & self, int64_t num_samples, bool replacement=false, Generator * generator=nullptr);
static inline Tensor & lgamma_out(Tensor & result, const Tensor & self);
static inline Tensor lgamma(const Tensor & self);
static inline Tensor & digamma_out(Tensor & result, const Tensor & self);
static inline Tensor digamma(const Tensor & self);
static inline Tensor & polygamma_out(Tensor & result, int64_t n, const Tensor & self);
static inline Tensor polygamma(int64_t n, const Tensor & self);
static inline Tensor & erfinv_out(Tensor & result, const Tensor & self);
static inline Tensor erfinv(const Tensor & self);
static inline Tensor & frac_out(Tensor & result, const Tensor & self);
static inline Tensor frac(const Tensor & self);
static inline Tensor dist(const Tensor & self, const Tensor & other, Scalar p=2);
static inline Tensor & reciprocal_out(Tensor & result, const Tensor & self);
static inline Tensor reciprocal(const Tensor & self);
static inline Tensor & neg_out(Tensor & result, const Tensor & self);
static inline Tensor neg(const Tensor & self);
static inline Tensor & atan2_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor atan2(const Tensor & self, const Tensor & other);
static inline Tensor & lerp_out(Tensor & result, const Tensor & self, const Tensor & end, Scalar weight);
static inline Tensor lerp(const Tensor & self, const Tensor & end, Scalar weight);
static inline Tensor & histc_out(Tensor & result, const Tensor & self, int64_t bins=100, Scalar min=0, Scalar max=0);
static inline Tensor histc(const Tensor & self, int64_t bins=100, Scalar min=0, Scalar max=0);
static inline Tensor & sign_out(Tensor & result, const Tensor & self);
static inline Tensor sign(const Tensor & self);
static inline Tensor & fmod_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor fmod(const Tensor & self, Scalar other);
static inline Tensor & fmod_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor fmod(const Tensor & self, const Tensor & other);
static inline Tensor & remainder_out(Tensor & result, const Tensor & self, Scalar other);
static inline Tensor remainder(const Tensor & self, Scalar other);
static inline Tensor & remainder_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor remainder(const Tensor & self, const Tensor & other);
static inline Tensor & min_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor min(const Tensor & self, const Tensor & other);
static inline Tensor min(const Tensor & self);
static inline Tensor & max_out(Tensor & result, const Tensor & self, const Tensor & other);
static inline Tensor max(const Tensor & self, const Tensor & other);
static inline Tensor max(const Tensor & self);
static inline Tensor median(const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> sort_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim=-1, bool descending=false);
static inline std::tuple<Tensor,Tensor> sort(const Tensor & self, int64_t dim=-1, bool descending=false);
static inline std::tuple<Tensor &,Tensor &> topk_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim=-1, bool largest=true, bool sorted=true);
static inline std::tuple<Tensor,Tensor> topk(const Tensor & self, int64_t k, int64_t dim=-1, bool largest=true, bool sorted=true);
static inline Tensor all(const Tensor & self);
static inline Tensor any(const Tensor & self);
static inline Tensor & renorm_out(Tensor & result, const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm);
static inline Tensor renorm(const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm);
static inline bool equal(const Tensor & self, const Tensor & other);
static inline Tensor & pow_out(Tensor & result, const Tensor & self, const Tensor & exponent);
static inline Tensor pow(const Tensor & self, const Tensor & exponent);
static inline Tensor & pow_out(Tensor & result, Scalar self, const Tensor & exponent);
static inline Tensor pow(Scalar self, const Tensor & exponent);
static inline Tensor & normal_out(Tensor & output, const Tensor & mean, double std=1, Generator * generator=nullptr);
static inline Tensor normal(const Tensor & mean, double std=1, Generator * generator=nullptr);
static inline Tensor & normal_out(Tensor & output, double mean, const Tensor & std, Generator * generator=nullptr);
static inline Tensor normal(double mean, const Tensor & std, Generator * generator=nullptr);
static inline Tensor & normal_out(Tensor & output, const Tensor & mean, const Tensor & std, Generator * generator=nullptr);
static inline Tensor normal(const Tensor & mean, const Tensor & std, Generator * generator=nullptr);
static inline Tensor alias(const Tensor & self);
static inline Tensor & _dirichlet_grad_out(Tensor & output, const Tensor & x, const Tensor & alpha, const Tensor & total);
static inline Tensor _dirichlet_grad(const Tensor & x, const Tensor & alpha, const Tensor & total);
static inline Tensor & binary_cross_entropy_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean);
static inline Tensor binary_cross_entropy(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean);
static inline Tensor & binary_cross_entropy_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
static inline Tensor binary_cross_entropy_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction);
static inline Tensor & mse_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor mse_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor & mse_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor mse_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & l1_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor l1_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor & l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & multi_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, Scalar p=1, Scalar margin=1, const Tensor & weight={}, int64_t reduction=Reduction::Mean);
static inline Tensor multi_margin_loss(const Tensor & self, const Tensor & target, Scalar p=1, Scalar margin=1, const Tensor & weight={}, int64_t reduction=Reduction::Mean);
static inline Tensor & multi_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction);
static inline 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);
static inline Tensor & multilabel_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor multilabel_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline std::tuple<Tensor &,Tensor &> multilabel_margin_loss_forward_out(Tensor & output, Tensor & is_target, const Tensor & self, const Tensor & target, int64_t reduction);
static inline std::tuple<Tensor,Tensor> multilabel_margin_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & multilabel_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target);
static inline Tensor multilabel_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target);
static inline Tensor & nll_loss_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean, int64_t ignore_index=-100);
static inline Tensor nll_loss(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean, int64_t ignore_index=-100);
static inline std::tuple<Tensor &,Tensor &> nll_loss_forward_out(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
static inline std::tuple<Tensor,Tensor> nll_loss_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
static inline Tensor & nll_loss_backward_out(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);
static inline 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);
static inline Tensor & nll_loss2d_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean, int64_t ignore_index=-100);
static inline Tensor nll_loss2d(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=Reduction::Mean, int64_t ignore_index=-100);
static inline std::tuple<Tensor &,Tensor &> nll_loss2d_forward_out(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
static inline std::tuple<Tensor,Tensor> nll_loss2d_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index);
static inline Tensor & nll_loss2d_backward_out(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);
static inline 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);
static inline Tensor & smooth_l1_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor smooth_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor & smooth_l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor smooth_l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & soft_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor soft_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction=Reduction::Mean);
static inline Tensor & soft_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor soft_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction);
static inline Tensor & elu_out(Tensor & output, const Tensor & self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1);
static inline Tensor elu(const Tensor & self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1);
static inline Tensor & elu_backward_out(Tensor & grad_input, const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output);
static inline Tensor elu_backward(const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output);
static inline Tensor & elu_(Tensor & self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1);
static inline Tensor & glu_out(Tensor & output, const Tensor & self, int64_t dim=-1);
static inline Tensor glu(const Tensor & self, int64_t dim=-1);
static inline Tensor & glu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, int64_t dim);
static inline Tensor glu_backward(const Tensor & grad_output, const Tensor & self, int64_t dim);
static inline Tensor & hardtanh_out(Tensor & output, const Tensor & self, Scalar min_val=-1, Scalar max_val=1);
static inline Tensor hardtanh(const Tensor & self, Scalar min_val=-1, Scalar max_val=1);
static inline Tensor & hardtanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val);
static inline Tensor hardtanh_backward(const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val);
static inline Tensor & hardtanh_(Tensor & self, Scalar min_val=-1, Scalar max_val=1);
static inline Tensor & leaky_relu_out(Tensor & output, const Tensor & self, Scalar negative_slope=0.01);
static inline Tensor leaky_relu(const Tensor & self, Scalar negative_slope=0.01);
static inline Tensor & leaky_relu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar negative_slope);
static inline Tensor leaky_relu_backward(const Tensor & grad_output, const Tensor & self, Scalar negative_slope);
static inline Tensor & leaky_relu_(Tensor & self, Scalar negative_slope=0.01);
static inline Tensor & log_sigmoid_out(Tensor & output, const Tensor & self);
static inline Tensor log_sigmoid(const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> log_sigmoid_forward_out(Tensor & output, Tensor & buffer, const Tensor & self);
static inline std::tuple<Tensor,Tensor> log_sigmoid_forward(const Tensor & self);
static inline Tensor & log_sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & buffer);
static inline Tensor log_sigmoid_backward(const Tensor & grad_output, const Tensor & self, const Tensor & buffer);
static inline Tensor & rrelu_with_noise_out(Tensor & output, const Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator * generator=nullptr);
static inline Tensor rrelu_with_noise(const Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator * generator=nullptr);
static inline Tensor & rrelu_with_noise_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training);
static inline Tensor rrelu_with_noise_backward(const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training);
static inline Tensor & rrelu_with_noise_(Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, Generator * generator=nullptr);
static inline Tensor & softplus_out(Tensor & output, const Tensor & self, Scalar beta=1, Scalar threshold=20);
static inline Tensor softplus(const Tensor & self, Scalar beta=1, Scalar threshold=20);
static inline Tensor & softplus_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output);
static inline Tensor softplus_backward(const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output);
static inline Tensor & softshrink_out(Tensor & output, const Tensor & self, Scalar lambd=0.5);
static inline Tensor softshrink(const Tensor & self, Scalar lambd=0.5);
static inline Tensor & softshrink_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar lambd);
static inline Tensor softshrink_backward(const Tensor & grad_output, const Tensor & self, Scalar lambd);
static inline Tensor & adaptive_avg_pool2d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor adaptive_avg_pool2d(const Tensor & self, IntList output_size);
static inline Tensor & adaptive_avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self);
static inline Tensor adaptive_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self);
static inline Tensor & adaptive_avg_pool3d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor adaptive_avg_pool3d(const Tensor & self, IntList output_size);
static inline Tensor & adaptive_avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self);
static inline Tensor adaptive_avg_pool3d_backward(const Tensor & grad_output, const Tensor & self);
static inline std::tuple<Tensor &,Tensor &> adaptive_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size);
static inline std::tuple<Tensor,Tensor> adaptive_max_pool2d(const Tensor & self, IntList output_size);
static inline Tensor & adaptive_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices);
static inline Tensor adaptive_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> adaptive_max_pool3d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size);
static inline std::tuple<Tensor,Tensor> adaptive_max_pool3d(const Tensor & self, IntList output_size);
static inline Tensor & adaptive_max_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices);
static inline Tensor adaptive_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices);
static inline Tensor & avg_pool2d_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor avg_pool2d(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor & avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor avg_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor & avg_pool3d_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor avg_pool3d(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor & avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline Tensor avg_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad);
static inline std::tuple<Tensor &,Tensor &> fractional_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples);
static inline std::tuple<Tensor,Tensor> fractional_max_pool2d(const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples);
static inline Tensor & fractional_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & indices);
static inline Tensor fractional_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> max_pool2d_with_indices_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline std::tuple<Tensor,Tensor> max_pool2d_with_indices(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline Tensor & max_pool2d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor max_pool2d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> max_pool3d_with_indices_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline std::tuple<Tensor,Tensor> max_pool3d_with_indices(const Tensor & self, IntList kernel_size, IntList stride={}, IntList padding=0, IntList dilation=1, bool ceil_mode=false);
static inline Tensor & max_pool3d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor max_pool3d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor & max_unpool2d_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor max_unpool2d(const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor & max_unpool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor max_unpool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size);
static inline Tensor & max_unpool3d_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor max_unpool3d(const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor & max_unpool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor max_unpool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding);
static inline Tensor & reflection_pad1d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor reflection_pad1d(const Tensor & self, IntList padding);
static inline Tensor & reflection_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor reflection_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & reflection_pad2d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor reflection_pad2d(const Tensor & self, IntList padding);
static inline Tensor & reflection_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor reflection_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & replication_pad1d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor replication_pad1d(const Tensor & self, IntList padding);
static inline Tensor & replication_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor replication_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & replication_pad2d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor replication_pad2d(const Tensor & self, IntList padding);
static inline Tensor & replication_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor replication_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & replication_pad3d_out(Tensor & output, const Tensor & self, IntList padding);
static inline Tensor replication_pad3d(const Tensor & self, IntList padding);
static inline Tensor & replication_pad3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor replication_pad3d_backward(const Tensor & grad_output, const Tensor & self, IntList padding);
static inline Tensor & upsample_linear1d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor upsample_linear1d(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & upsample_linear1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor upsample_linear1d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor & upsample_bilinear2d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor upsample_bilinear2d(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & upsample_bilinear2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor upsample_bilinear2d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor & upsample_trilinear3d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor upsample_trilinear3d(const Tensor & self, IntList output_size, bool align_corners);
static inline Tensor & upsample_trilinear3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor upsample_trilinear3d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners);
static inline Tensor & upsample_nearest1d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor upsample_nearest1d(const Tensor & self, IntList output_size);
static inline Tensor & upsample_nearest1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor upsample_nearest1d_backward(const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor & upsample_nearest2d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor upsample_nearest2d(const Tensor & self, IntList output_size);
static inline Tensor & upsample_nearest2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor upsample_nearest2d_backward(const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor & upsample_nearest3d_out(Tensor & output, const Tensor & self, IntList output_size);
static inline Tensor upsample_nearest3d(const Tensor & self, IntList output_size);
static inline Tensor & upsample_nearest3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor upsample_nearest3d_backward(const Tensor & grad_output, IntList output_size, IntList input_size);
static inline Tensor & sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output);
static inline Tensor sigmoid_backward(const Tensor & grad_output, const Tensor & output);
static inline Tensor & tanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output);
static inline Tensor tanh_backward(const Tensor & grad_output, const Tensor & output);
static inline Tensor & thnn_conv_transpose2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, IntList dilation=1);
static inline Tensor thnn_conv_transpose2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, IntList dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_transpose2d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_transpose2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_transpose2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & columns, const Tensor & ones);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_transpose2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask);
static inline Tensor & thnn_conv_transpose3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, IntList dilation=1);
static inline Tensor thnn_conv_transpose3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList output_padding=0, IntList dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_transpose3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_transpose3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_transpose3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & finput, const Tensor & fgrad_input);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_transpose3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
static inline Tensor & thnn_conv2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0);
static inline Tensor thnn_conv2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv2d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
static inline Tensor & thnn_conv_depthwise2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline Tensor thnn_conv_depthwise2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline Tensor & thnn_conv_depthwise2d_forward_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline Tensor thnn_conv_depthwise2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &> thnn_conv_depthwise2d_backward_out(Tensor & grad_input, Tensor & grad_weight, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor,Tensor> thnn_conv_depthwise2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, std::array<bool,2> output_mask);
static inline Tensor & thnn_conv3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0);
static inline Tensor thnn_conv3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
static inline Tensor & thnn_conv_dilated2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline Tensor thnn_conv_dilated2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_dilated2d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_dilated2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_dilated2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_dilated2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask);
static inline Tensor & thnn_conv_dilated3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline Tensor thnn_conv_dilated3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias={}, IntList stride=1, IntList padding=0, IntList dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_dilated3d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_dilated3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation);
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_dilated3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_dilated3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask);

namespace detail {

static inline TypeExtendedInterface & infer_type(const Tensor & t) {
  AT_CHECK(t.defined(), "undefined Tensor");
  return getType(t);
}
static inline TypeExtendedInterface & infer_type(const TensorList & tl) {
  AT_CHECK(tl.size() > 0, "expected a non-empty list of Tensors");
  return getType(tl[0]);
}

} // namespace detail

// function definitions are all static inline because
// they are one-line statically dispatched functions that
// invoke the actual dynamic dispatch on the correct argument
static inline Tensor & _th_set_(Tensor & self, Storage source) {
    return detail::infer_type(self)._th_set_(self, source);
}
static inline Tensor & _th_set_(Tensor & self, Storage source, int64_t storage_offset, IntList size, IntList stride) {
    return detail::infer_type(self)._th_set_(self, source, storage_offset, size, stride);
}
static inline Tensor & _th_set_(Tensor & self, const Tensor & source) {
    return detail::infer_type(self)._th_set_(self, source);
}
static inline Tensor & _th_set_(Tensor & self) {
    return detail::infer_type(self)._th_set_(self);
}
static inline Tensor & _th_fill_(Tensor & self, Scalar value) {
    return detail::infer_type(self)._th_fill_(self, value);
}
static inline Tensor & _th_fill_(Tensor & self, const Tensor & value) {
    return detail::infer_type(self)._th_fill_(self, value);
}
static inline bool _th_is_set_to(const Tensor & self, const Tensor & tensor) {
    return detail::infer_type(self)._th_is_set_to(self, tensor);
}
static inline Tensor & _th_masked_fill_(Tensor & self, const Tensor & mask, Scalar value) {
    return detail::infer_type(self)._th_masked_fill_(self, mask, value);
}
static inline Tensor & _th_masked_fill_(Tensor & self, const Tensor & mask, const Tensor & value) {
    return detail::infer_type(self)._th_masked_fill_(self, mask, value);
}
static inline Tensor & _th_masked_scatter_(Tensor & self, const Tensor & mask, const Tensor & source) {
    return detail::infer_type(self)._th_masked_scatter_(self, mask, source);
}
static inline Tensor & _th_masked_select_out(Tensor & result, const Tensor & self, const Tensor & mask) {
    return detail::infer_type(self)._th_masked_select_out(result, self, mask);
}
static inline Tensor _th_masked_select(const Tensor & self, const Tensor & mask) {
    return detail::infer_type(self)._th_masked_select(self, mask);
}
static inline Tensor & _th_nonzero_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_nonzero_out(result, self);
}
static inline Tensor _th_nonzero(const Tensor & self) {
    return detail::infer_type(self)._th_nonzero(self);
}
static inline Tensor _th_clone(const Tensor & self) {
    return detail::infer_type(self)._th_clone(self);
}
static inline Tensor _th_view(const Tensor & self, IntList size) {
    return detail::infer_type(self)._th_view(self, size);
}
static inline Tensor & _th_resize_as_(Tensor & self, const Tensor & the_template) {
    return detail::infer_type(self)._th_resize_as_(self, the_template);
}
static inline Tensor & _th_index_select_out(Tensor & result, const Tensor & self, int64_t dim, const Tensor & index) {
    return detail::infer_type(self)._th_index_select_out(result, self, dim, index);
}
static inline Tensor _th_index_select(const Tensor & self, int64_t dim, const Tensor & index) {
    return detail::infer_type(self)._th_index_select(self, dim, index);
}
static inline Tensor & _th_index_copy_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & source) {
    return detail::infer_type(self)._th_index_copy_(self, dim, index, source);
}
static inline Tensor & _th_take_out(Tensor & result, const Tensor & self, const Tensor & index) {
    return detail::infer_type(self)._th_take_out(result, self, index);
}
static inline Tensor _th_take(const Tensor & self, const Tensor & index) {
    return detail::infer_type(self)._th_take(self, index);
}
static inline Tensor & _th_put_(Tensor & self, const Tensor & index, const Tensor & source, bool accumulate) {
    return detail::infer_type(self)._th_put_(self, index, source, accumulate);
}
static inline Tensor & _th_index_add_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & source) {
    return detail::infer_type(self)._th_index_add_(self, dim, index, source);
}
static inline Tensor & _th_index_fill_(Tensor & self, int64_t dim, const Tensor & index, Scalar value) {
    return detail::infer_type(self)._th_index_fill_(self, dim, index, value);
}
static inline Tensor & _th_index_fill_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & value) {
    return detail::infer_type(self)._th_index_fill_(self, dim, index, value);
}
static inline Tensor & _th_unfold_out(Tensor & result, const Tensor & self, int64_t dimension, int64_t size, int64_t step) {
    return detail::infer_type(self)._th_unfold_out(result, self, dimension, size, step);
}
static inline Tensor _th_unfold(const Tensor & self, int64_t dimension, int64_t size, int64_t step) {
    return detail::infer_type(self)._th_unfold(self, dimension, size, step);
}
static inline Tensor & _th_range_out(Tensor & result, Scalar start, Scalar end, Scalar step) {
    return detail::infer_type(result)._th_range_out(result, start, end, step);
}
static inline Tensor & _th_arange_out(Tensor & result, Scalar start, Scalar end, Scalar step) {
    return detail::infer_type(result)._th_arange_out(result, start, end, step);
}
static inline Tensor & _th_arange_out(Tensor & result, Scalar end) {
    return detail::infer_type(result)._th_arange_out(result, end);
}
static inline Tensor & _th_scatter_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & src) {
    return detail::infer_type(self)._th_scatter_(self, dim, index, src);
}
static inline Tensor & _th_scatter_(Tensor & self, int64_t dim, const Tensor & index, Scalar value) {
    return detail::infer_type(self)._th_scatter_(self, dim, index, value);
}
static inline Tensor & _th_scatter_add_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & src) {
    return detail::infer_type(self)._th_scatter_add_(self, dim, index, src);
}
static inline Tensor & _th_gather_out(Tensor & result, const Tensor & self, int64_t dim, const Tensor & index) {
    return detail::infer_type(self)._th_gather_out(result, self, dim, index);
}
static inline Tensor _th_gather(const Tensor & self, int64_t dim, const Tensor & index) {
    return detail::infer_type(self)._th_gather(self, dim, index);
}
static inline bool _th_equal(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_equal(self, other);
}
static inline Tensor & _th_and_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_and_out(result, self, other);
}
static inline Tensor _th_and(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_and(self, other);
}
static inline Tensor & _th_and_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_and_out(result, self, other);
}
static inline Tensor _th_and(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_and(self, other);
}
static inline Tensor & _th_iand_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_iand_(self, other);
}
static inline Tensor & _th_iand_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_iand_(self, other);
}
static inline Tensor & _th_or_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_or_out(result, self, other);
}
static inline Tensor _th_or(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_or(self, other);
}
static inline Tensor & _th_or_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_or_out(result, self, other);
}
static inline Tensor _th_or(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_or(self, other);
}
static inline Tensor & _th_ior_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ior_(self, other);
}
static inline Tensor & _th_ior_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ior_(self, other);
}
static inline Tensor & _th_xor_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_xor_out(result, self, other);
}
static inline Tensor _th_xor(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_xor(self, other);
}
static inline Tensor & _th_xor_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_xor_out(result, self, other);
}
static inline Tensor _th_xor(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_xor(self, other);
}
static inline Tensor & _th_ixor_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ixor_(self, other);
}
static inline Tensor & _th_ixor_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ixor_(self, other);
}
static inline Tensor & _th_lshift_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_lshift_out(result, self, other);
}
static inline Tensor _th_lshift(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_lshift(self, other);
}
static inline Tensor & _th_lshift_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_lshift_out(result, self, other);
}
static inline Tensor _th_lshift(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_lshift(self, other);
}
static inline Tensor & _th_ilshift_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ilshift_(self, other);
}
static inline Tensor & _th_ilshift_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ilshift_(self, other);
}
static inline Tensor & _th_rshift_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_rshift_out(result, self, other);
}
static inline Tensor _th_rshift(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_rshift(self, other);
}
static inline Tensor & _th_rshift_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_rshift_out(result, self, other);
}
static inline Tensor _th_rshift(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_rshift(self, other);
}
static inline Tensor & _th_irshift_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_irshift_(self, other);
}
static inline Tensor & _th_irshift_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_irshift_(self, other);
}
static inline Tensor & _th_lt_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_lt_out(result, self, other);
}
static inline Tensor _th_lt(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_lt(self, other);
}
static inline Tensor & _th_lt_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_lt_out(result, self, other);
}
static inline Tensor _th_lt(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_lt(self, other);
}
static inline Tensor & _th_lt_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_lt_(self, other);
}
static inline Tensor & _th_lt_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_lt_(self, other);
}
static inline Tensor & _th_gt_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_gt_out(result, self, other);
}
static inline Tensor _th_gt(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_gt(self, other);
}
static inline Tensor & _th_gt_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_gt_out(result, self, other);
}
static inline Tensor _th_gt(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_gt(self, other);
}
static inline Tensor & _th_gt_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_gt_(self, other);
}
static inline Tensor & _th_gt_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_gt_(self, other);
}
static inline Tensor & _th_le_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_le_out(result, self, other);
}
static inline Tensor _th_le(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_le(self, other);
}
static inline Tensor & _th_le_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_le_out(result, self, other);
}
static inline Tensor _th_le(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_le(self, other);
}
static inline Tensor & _th_le_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_le_(self, other);
}
static inline Tensor & _th_le_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_le_(self, other);
}
static inline Tensor & _th_ge_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ge_out(result, self, other);
}
static inline Tensor _th_ge(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ge(self, other);
}
static inline Tensor & _th_ge_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ge_out(result, self, other);
}
static inline Tensor _th_ge(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ge(self, other);
}
static inline Tensor & _th_ge_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ge_(self, other);
}
static inline Tensor & _th_ge_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ge_(self, other);
}
static inline Tensor & _th_eq_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_eq_out(result, self, other);
}
static inline Tensor _th_eq(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_eq(self, other);
}
static inline Tensor & _th_eq_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_eq_out(result, self, other);
}
static inline Tensor _th_eq(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_eq(self, other);
}
static inline Tensor & _th_eq_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_eq_(self, other);
}
static inline Tensor & _th_eq_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_eq_(self, other);
}
static inline Tensor & _th_ne_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ne_out(result, self, other);
}
static inline Tensor _th_ne(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ne(self, other);
}
static inline Tensor & _th_ne_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ne_out(result, self, other);
}
static inline Tensor _th_ne(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ne(self, other);
}
static inline Tensor & _th_ne_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_ne_(self, other);
}
static inline Tensor & _th_ne_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_ne_(self, other);
}
static inline Tensor & _th_min_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_min_out(result, self, other);
}
static inline Tensor _th_min(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_min(self, other);
}
static inline Tensor _th_min(const Tensor & self) {
    return detail::infer_type(self)._th_min(self);
}
static inline std::tuple<Tensor &,Tensor &> _th_min_out(Tensor & min, Tensor & min_indices, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_min_out(min, min_indices, self, dim, keepdim);
}
static inline std::tuple<Tensor,Tensor> _th_min(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_min(self, dim, keepdim);
}
static inline Tensor & _th_max_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_max_out(result, self, other);
}
static inline Tensor _th_max(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_max(self, other);
}
static inline Tensor _th_max(const Tensor & self) {
    return detail::infer_type(self)._th_max(self);
}
static inline std::tuple<Tensor &,Tensor &> _th_max_out(Tensor & max, Tensor & max_indices, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_max_out(max, max_indices, self, dim, keepdim);
}
static inline std::tuple<Tensor,Tensor> _th_max(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_max(self, dim, keepdim);
}
static inline std::tuple<Tensor &,Tensor &> _th_kthvalue_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_kthvalue_out(values, indices, self, k, dim, keepdim);
}
static inline std::tuple<Tensor,Tensor> _th_kthvalue(const Tensor & self, int64_t k, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_kthvalue(self, k, dim, keepdim);
}
static inline std::tuple<Tensor &,Tensor &> _th_mode_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_mode_out(values, indices, self, dim, keepdim);
}
static inline std::tuple<Tensor,Tensor> _th_mode(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_mode(self, dim, keepdim);
}
static inline Tensor _th_median(const Tensor & self) {
    return detail::infer_type(self)._th_median(self);
}
static inline std::tuple<Tensor &,Tensor &> _th_median_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_median_out(values, indices, self, dim, keepdim);
}
static inline std::tuple<Tensor,Tensor> _th_median(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_median(self, dim, keepdim);
}
static inline std::tuple<Tensor &,Tensor &> _th_sort_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool descending) {
    return detail::infer_type(self)._th_sort_out(values, indices, self, dim, descending);
}
static inline std::tuple<Tensor,Tensor> _th_sort(const Tensor & self, int64_t dim, bool descending) {
    return detail::infer_type(self)._th_sort(self, dim, descending);
}
static inline std::tuple<Tensor &,Tensor &> _th_topk_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted) {
    return detail::infer_type(self)._th_topk_out(values, indices, self, k, dim, largest, sorted);
}
static inline std::tuple<Tensor,Tensor> _th_topk(const Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted) {
    return detail::infer_type(self)._th_topk(self, k, dim, largest, sorted);
}
static inline Tensor _th_all(const Tensor & self) {
    return detail::infer_type(self)._th_all(self);
}
static inline Tensor & _th_all_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_all_out(result, self, dim, keepdim);
}
static inline Tensor _th_all(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_all(self, dim, keepdim);
}
static inline Tensor _th_any(const Tensor & self) {
    return detail::infer_type(self)._th_any(self);
}
static inline Tensor & _th_any_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_any_out(result, self, dim, keepdim);
}
static inline Tensor _th_any(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_any(self, dim, keepdim);
}
static inline Tensor & _th_abs_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_abs_out(result, self);
}
static inline Tensor _th_abs(const Tensor & self) {
    return detail::infer_type(self)._th_abs(self);
}
static inline Tensor & _th_sigmoid_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_sigmoid_out(result, self);
}
static inline Tensor _th_sigmoid(const Tensor & self) {
    return detail::infer_type(self)._th_sigmoid(self);
}
static inline Tensor & _th_log_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_log_out(result, self);
}
static inline Tensor _th_log(const Tensor & self) {
    return detail::infer_type(self)._th_log(self);
}
static inline Tensor & _th_log10_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_log10_out(result, self);
}
static inline Tensor _th_log10(const Tensor & self) {
    return detail::infer_type(self)._th_log10(self);
}
static inline Tensor & _th_log1p_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_log1p_out(result, self);
}
static inline Tensor _th_log1p(const Tensor & self) {
    return detail::infer_type(self)._th_log1p(self);
}
static inline Tensor & _th_log2_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_log2_out(result, self);
}
static inline Tensor _th_log2(const Tensor & self) {
    return detail::infer_type(self)._th_log2(self);
}
static inline Tensor & _th_lgamma_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_lgamma_out(result, self);
}
static inline Tensor _th_lgamma(const Tensor & self) {
    return detail::infer_type(self)._th_lgamma(self);
}
static inline Tensor & _th_lgamma_(Tensor & self) {
    return detail::infer_type(self)._th_lgamma_(self);
}
static inline Tensor & _th_digamma_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_digamma_out(result, self);
}
static inline Tensor _th_digamma(const Tensor & self) {
    return detail::infer_type(self)._th_digamma(self);
}
static inline Tensor & _th_digamma_(Tensor & self) {
    return detail::infer_type(self)._th_digamma_(self);
}
static inline Tensor & _th_polygamma_out(Tensor & result, int64_t n, const Tensor & self) {
    return detail::infer_type(self)._th_polygamma_out(result, n, self);
}
static inline Tensor _th_polygamma(int64_t n, const Tensor & self) {
    return detail::infer_type(self)._th_polygamma(n, self);
}
static inline Tensor & _th_polygamma_(Tensor & self, int64_t n) {
    return detail::infer_type(self)._th_polygamma_(self, n);
}
static inline Tensor & _th_exp_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_exp_out(result, self);
}
static inline Tensor _th_exp(const Tensor & self) {
    return detail::infer_type(self)._th_exp(self);
}
static inline Tensor & _th_expm1_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_expm1_out(result, self);
}
static inline Tensor _th_expm1(const Tensor & self) {
    return detail::infer_type(self)._th_expm1(self);
}
static inline Tensor & _th_cos_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_cos_out(result, self);
}
static inline Tensor _th_cos(const Tensor & self) {
    return detail::infer_type(self)._th_cos(self);
}
static inline Tensor & _th_acos_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_acos_out(result, self);
}
static inline Tensor _th_acos(const Tensor & self) {
    return detail::infer_type(self)._th_acos(self);
}
static inline Tensor & _th_cosh_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_cosh_out(result, self);
}
static inline Tensor _th_cosh(const Tensor & self) {
    return detail::infer_type(self)._th_cosh(self);
}
static inline Tensor & _th_sin_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_sin_out(result, self);
}
static inline Tensor _th_sin(const Tensor & self) {
    return detail::infer_type(self)._th_sin(self);
}
static inline Tensor & _th_asin_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_asin_out(result, self);
}
static inline Tensor _th_asin(const Tensor & self) {
    return detail::infer_type(self)._th_asin(self);
}
static inline Tensor & _th_sinh_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_sinh_out(result, self);
}
static inline Tensor _th_sinh(const Tensor & self) {
    return detail::infer_type(self)._th_sinh(self);
}
static inline Tensor & _th_tan_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_tan_out(result, self);
}
static inline Tensor _th_tan(const Tensor & self) {
    return detail::infer_type(self)._th_tan(self);
}
static inline Tensor & _th_atan_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_atan_out(result, self);
}
static inline Tensor _th_atan(const Tensor & self) {
    return detail::infer_type(self)._th_atan(self);
}
static inline Tensor & _th_tanh_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_tanh_out(result, self);
}
static inline Tensor _th_tanh(const Tensor & self) {
    return detail::infer_type(self)._th_tanh(self);
}
static inline Tensor & _th_erf_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_erf_out(result, self);
}
static inline Tensor _th_erf(const Tensor & self) {
    return detail::infer_type(self)._th_erf(self);
}
static inline Tensor & _th_erfc_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_erfc_out(result, self);
}
static inline Tensor _th_erfc(const Tensor & self) {
    return detail::infer_type(self)._th_erfc(self);
}
static inline Tensor & _th_erfinv_(Tensor & self) {
    return detail::infer_type(self)._th_erfinv_(self);
}
static inline Tensor & _th_erfinv_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_erfinv_out(result, self);
}
static inline Tensor _th_erfinv(const Tensor & self) {
    return detail::infer_type(self)._th_erfinv(self);
}
static inline Tensor & _th_sqrt_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_sqrt_out(result, self);
}
static inline Tensor _th_sqrt(const Tensor & self) {
    return detail::infer_type(self)._th_sqrt(self);
}
static inline Tensor & _th_rsqrt_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_rsqrt_out(result, self);
}
static inline Tensor _th_rsqrt(const Tensor & self) {
    return detail::infer_type(self)._th_rsqrt(self);
}
static inline Tensor & _th_ceil_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_ceil_out(result, self);
}
static inline Tensor _th_ceil(const Tensor & self) {
    return detail::infer_type(self)._th_ceil(self);
}
static inline Tensor & _th_floor_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_floor_out(result, self);
}
static inline Tensor _th_floor(const Tensor & self) {
    return detail::infer_type(self)._th_floor(self);
}
static inline Tensor & _th_round_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_round_out(result, self);
}
static inline Tensor _th_round(const Tensor & self) {
    return detail::infer_type(self)._th_round(self);
}
static inline Tensor & _th_trunc_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_trunc_out(result, self);
}
static inline Tensor _th_trunc(const Tensor & self) {
    return detail::infer_type(self)._th_trunc(self);
}
static inline Tensor & _th_frac_(Tensor & self) {
    return detail::infer_type(self)._th_frac_(self);
}
static inline Tensor & _th_frac_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_frac_out(result, self);
}
static inline Tensor _th_frac(const Tensor & self) {
    return detail::infer_type(self)._th_frac(self);
}
static inline Tensor & _th_var_out(Tensor & result, const Tensor & self, int64_t dim, bool unbiased, bool keepdim) {
    return detail::infer_type(self)._th_var_out(result, self, dim, unbiased, keepdim);
}
static inline Tensor _th_var(const Tensor & self, int64_t dim, bool unbiased, bool keepdim) {
    return detail::infer_type(self)._th_var(self, dim, unbiased, keepdim);
}
static inline Tensor _th_var(const Tensor & self, bool unbiased) {
    return detail::infer_type(self)._th_var(self, unbiased);
}
static inline Tensor & _th_std_out(Tensor & result, const Tensor & self, int64_t dim, bool unbiased, bool keepdim) {
    return detail::infer_type(self)._th_std_out(result, self, dim, unbiased, keepdim);
}
static inline Tensor _th_std(const Tensor & self, int64_t dim, bool unbiased, bool keepdim) {
    return detail::infer_type(self)._th_std(self, dim, unbiased, keepdim);
}
static inline Tensor _th_std(const Tensor & self, bool unbiased) {
    return detail::infer_type(self)._th_std(self, unbiased);
}
static inline Tensor _th_norm(const Tensor & self, Scalar p) {
    return detail::infer_type(self)._th_norm(self, p);
}
static inline Tensor & _th_norm_out(Tensor & result, const Tensor & self, Scalar p, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_norm_out(result, self, p, dim, keepdim);
}
static inline Tensor _th_norm(const Tensor & self, Scalar p, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._th_norm(self, p, dim, keepdim);
}
static inline Tensor & _th_renorm_out(Tensor & result, const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm) {
    return detail::infer_type(self)._th_renorm_out(result, self, p, dim, maxnorm);
}
static inline Tensor _th_renorm(const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm) {
    return detail::infer_type(self)._th_renorm(self, p, dim, maxnorm);
}
static inline Tensor & _th_renorm_(Tensor & self, Scalar p, int64_t dim, Scalar maxnorm) {
    return detail::infer_type(self)._th_renorm_(self, p, dim, maxnorm);
}
static inline Tensor _th_dist(const Tensor & self, const Tensor & other, Scalar p) {
    return detail::infer_type(self)._th_dist(self, other, p);
}
static inline Tensor & _th_reciprocal_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_reciprocal_out(result, self);
}
static inline Tensor _th_reciprocal(const Tensor & self) {
    return detail::infer_type(self)._th_reciprocal(self);
}
static inline Tensor & _th_reciprocal_(Tensor & self) {
    return detail::infer_type(self)._th_reciprocal_(self);
}
static inline Tensor & _th_neg_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_neg_out(result, self);
}
static inline Tensor _th_neg(const Tensor & self) {
    return detail::infer_type(self)._th_neg(self);
}
static inline Tensor & _th_neg_(Tensor & self) {
    return detail::infer_type(self)._th_neg_(self);
}
static inline Tensor & _th_atan2_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_atan2_out(result, self, other);
}
static inline Tensor _th_atan2(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_atan2(self, other);
}
static inline Tensor & _th_atan2_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_atan2_(self, other);
}
static inline Tensor & _th_pow_out(Tensor & result, const Tensor & self, Scalar exponent) {
    return detail::infer_type(self)._th_pow_out(result, self, exponent);
}
static inline Tensor _th_pow(const Tensor & self, Scalar exponent) {
    return detail::infer_type(self)._th_pow(self, exponent);
}
static inline Tensor & _th_pow_out(Tensor & result, const Tensor & self, const Tensor & exponent) {
    return detail::infer_type(self)._th_pow_out(result, self, exponent);
}
static inline Tensor _th_pow(const Tensor & self, const Tensor & exponent) {
    return detail::infer_type(self)._th_pow(self, exponent);
}
static inline Tensor & _th_pow_out(Tensor & result, Scalar self, const Tensor & exponent) {
    return detail::infer_type(result)._th_pow_out(result, self, exponent);
}
static inline Tensor _th_pow(Scalar self, const Tensor & exponent) {
    return detail::infer_type(exponent)._th_pow(self, exponent);
}
static inline Tensor & _th_pow_(Tensor & self, Scalar exponent) {
    return detail::infer_type(self)._th_pow_(self, exponent);
}
static inline Tensor & _th_pow_(Tensor & self, const Tensor & exponent) {
    return detail::infer_type(self)._th_pow_(self, exponent);
}
static inline Tensor & _th_lerp_out(Tensor & result, const Tensor & self, const Tensor & end, Scalar weight) {
    return detail::infer_type(self)._th_lerp_out(result, self, end, weight);
}
static inline Tensor _th_lerp(const Tensor & self, const Tensor & end, Scalar weight) {
    return detail::infer_type(self)._th_lerp(self, end, weight);
}
static inline Tensor & _th_lerp_(Tensor & self, const Tensor & end, Scalar weight) {
    return detail::infer_type(self)._th_lerp_(self, end, weight);
}
static inline Tensor & _th_linspace_out(Tensor & result, Scalar start, Scalar end, int64_t steps) {
    return detail::infer_type(result)._th_linspace_out(result, start, end, steps);
}
static inline Tensor & _th_logspace_out(Tensor & result, Scalar start, Scalar end, int64_t steps) {
    return detail::infer_type(result)._th_logspace_out(result, start, end, steps);
}
static inline Tensor & _th_histc_out(Tensor & result, const Tensor & self, int64_t bins, Scalar min, Scalar max) {
    return detail::infer_type(self)._th_histc_out(result, self, bins, min, max);
}
static inline Tensor _th_histc(const Tensor & self, int64_t bins, Scalar min, Scalar max) {
    return detail::infer_type(self)._th_histc(self, bins, min, max);
}
static inline Tensor & _th_zero_(Tensor & self) {
    return detail::infer_type(self)._th_zero_(self);
}
static inline Tensor & _th_cumsum_out(Tensor & result, const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._th_cumsum_out(result, self, dim);
}
static inline Tensor _th_cumsum(const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._th_cumsum(self, dim);
}
static inline Tensor & _th_cumprod_out(Tensor & result, const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._th_cumprod_out(result, self, dim);
}
static inline Tensor _th_cumprod(const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._th_cumprod(self, dim);
}
static inline Tensor & _th_sign_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self)._th_sign_out(result, self);
}
static inline Tensor _th_sign(const Tensor & self) {
    return detail::infer_type(self)._th_sign(self);
}
static inline Tensor & _th_sign_(Tensor & self) {
    return detail::infer_type(self)._th_sign_(self);
}
static inline Tensor _th_trace(const Tensor & self) {
    return detail::infer_type(self)._th_trace(self);
}
static inline Tensor & _th_fmod_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_fmod_out(result, self, other);
}
static inline Tensor _th_fmod(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_fmod(self, other);
}
static inline Tensor & _th_fmod_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_fmod_out(result, self, other);
}
static inline Tensor _th_fmod(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_fmod(self, other);
}
static inline Tensor & _th_fmod_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_fmod_(self, other);
}
static inline Tensor & _th_fmod_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_fmod_(self, other);
}
static inline Tensor & _th_remainder_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_remainder_out(result, self, other);
}
static inline Tensor _th_remainder(const Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_remainder(self, other);
}
static inline Tensor & _th_remainder_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_remainder_out(result, self, other);
}
static inline Tensor _th_remainder(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_remainder(self, other);
}
static inline Tensor & _th_remainder_(Tensor & self, Scalar other) {
    return detail::infer_type(self)._th_remainder_(self, other);
}
static inline Tensor & _th_remainder_(Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._th_remainder_(self, other);
}
static inline Tensor & _th_clamp_out(Tensor & result, const Tensor & self, Scalar min, Scalar max) {
    return detail::infer_type(self)._th_clamp_out(result, self, min, max);
}
static inline Tensor _th_clamp(const Tensor & self, Scalar min, Scalar max) {
    return detail::infer_type(self)._th_clamp(self, min, max);
}
static inline Tensor & _th_clamp_min_out(Tensor & result, const Tensor & self, Scalar min) {
    return detail::infer_type(self)._th_clamp_min_out(result, self, min);
}
static inline Tensor _th_clamp_min(const Tensor & self, Scalar min) {
    return detail::infer_type(self)._th_clamp_min(self, min);
}
static inline Tensor & _th_clamp_max_out(Tensor & result, const Tensor & self, Scalar max) {
    return detail::infer_type(self)._th_clamp_max_out(result, self, max);
}
static inline Tensor _th_clamp_max(const Tensor & self, Scalar max) {
    return detail::infer_type(self)._th_clamp_max(self, max);
}
static inline Tensor _th_dot(const Tensor & self, const Tensor & tensor) {
    return detail::infer_type(self)._th_dot(self, tensor);
}
static inline Tensor & _th_cross_out(Tensor & result, const Tensor & self, const Tensor & other, int64_t dim) {
    return detail::infer_type(self)._th_cross_out(result, self, other, dim);
}
static inline Tensor _th_cross(const Tensor & self, const Tensor & other, int64_t dim) {
    return detail::infer_type(self)._th_cross(self, other, dim);
}
static inline Tensor & _th_diag_out(Tensor & result, const Tensor & self, int64_t diagonal) {
    return detail::infer_type(self)._th_diag_out(result, self, diagonal);
}
static inline Tensor _th_diag(const Tensor & self, int64_t diagonal) {
    return detail::infer_type(self)._th_diag(self, diagonal);
}
static inline Tensor & _th_addmm_out(Tensor & result, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addmm_out(result, self, mat1, mat2, beta, alpha);
}
static inline Tensor _th_addmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addmm(self, mat1, mat2, beta, alpha);
}
static inline Tensor & _th_addmm_(Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addmm_(self, mat1, mat2, beta, alpha);
}
static inline Tensor & _th_addmv_out(Tensor & result, const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addmv_out(result, self, mat, vec, beta, alpha);
}
static inline Tensor _th_addmv(const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addmv(self, mat, vec, beta, alpha);
}
static inline Tensor & _th_addmv_(Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addmv_(self, mat, vec, beta, alpha);
}
static inline Tensor & _th_addr_out(Tensor & result, const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addr_out(result, self, vec1, vec2, beta, alpha);
}
static inline Tensor _th_addr(const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addr(self, vec1, vec2, beta, alpha);
}
static inline Tensor & _th_addr_(Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addr_(self, vec1, vec2, beta, alpha);
}
static inline Tensor & _th_ger_out(Tensor & result, const Tensor & self, const Tensor & vec2) {
    return detail::infer_type(self)._th_ger_out(result, self, vec2);
}
static inline Tensor _th_ger(const Tensor & self, const Tensor & vec2) {
    return detail::infer_type(self)._th_ger(self, vec2);
}
static inline Tensor & _th_mv_out(Tensor & result, const Tensor & self, const Tensor & vec) {
    return detail::infer_type(self)._th_mv_out(result, self, vec);
}
static inline Tensor _th_mv(const Tensor & self, const Tensor & vec) {
    return detail::infer_type(self)._th_mv(self, vec);
}
static inline Tensor & _th_mm_out(Tensor & result, const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self)._th_mm_out(result, self, mat2);
}
static inline Tensor _th_mm(const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self)._th_mm(self, mat2);
}
static inline Tensor & _th_bmm_out(Tensor & result, const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self)._th_bmm_out(result, self, mat2);
}
static inline Tensor _th_bmm(const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self)._th_bmm(self, mat2);
}
static inline Tensor & _th_addbmm_out(Tensor & result, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addbmm_out(result, self, batch1, batch2, beta, alpha);
}
static inline Tensor _th_addbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addbmm(self, batch1, batch2, beta, alpha);
}
static inline Tensor & _th_addbmm_(Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_addbmm_(self, batch1, batch2, beta, alpha);
}
static inline Tensor & _th_baddbmm_out(Tensor & result, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_baddbmm_out(result, self, batch1, batch2, beta, alpha);
}
static inline Tensor _th_baddbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._th_baddbmm(self, batch1, batch2, beta, alpha);
}
static inline Tensor & _th_addcmul_out(Tensor & result, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self)._th_addcmul_out(result, self, tensor1, tensor2, value);
}
static inline Tensor _th_addcmul(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self)._th_addcmul(self, tensor1, tensor2, value);
}
static inline Tensor & _th_addcmul_(Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self)._th_addcmul_(self, tensor1, tensor2, value);
}
static inline Tensor & _th_addcdiv_out(Tensor & result, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self)._th_addcdiv_out(result, self, tensor1, tensor2, value);
}
static inline Tensor _th_addcdiv(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self)._th_addcdiv(self, tensor1, tensor2, value);
}
static inline Tensor & _th_addcdiv_(Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self)._th_addcdiv_(self, tensor1, tensor2, value);
}
static inline std::tuple<Tensor &,Tensor &> _th_gesv_single_out(Tensor & solution, Tensor & lu, const Tensor & self, const Tensor & A) {
    return detail::infer_type(self)._th_gesv_single_out(solution, lu, self, A);
}
static inline std::tuple<Tensor,Tensor> _th_gesv_single(const Tensor & self, const Tensor & A) {
    return detail::infer_type(self)._th_gesv_single(self, A);
}
static inline std::tuple<Tensor &,Tensor &> _th_gels_out(Tensor & res1, Tensor & res2, const Tensor & self, const Tensor & A) {
    return detail::infer_type(self)._th_gels_out(res1, res2, self, A);
}
static inline std::tuple<Tensor,Tensor> _th_gels(const Tensor & self, const Tensor & A) {
    return detail::infer_type(self)._th_gels(self, A);
}
static inline std::tuple<Tensor &,Tensor &> _th_trtrs_out(Tensor & res1, Tensor & res2, const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular) {
    return detail::infer_type(self)._th_trtrs_out(res1, res2, self, A, upper, transpose, unitriangular);
}
static inline std::tuple<Tensor,Tensor> _th_trtrs(const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular) {
    return detail::infer_type(self)._th_trtrs(self, A, upper, transpose, unitriangular);
}
static inline std::tuple<Tensor &,Tensor &> _th_symeig_out(Tensor & res1, Tensor & res2, const Tensor & self, bool eigenvectors, bool upper) {
    return detail::infer_type(self)._th_symeig_out(res1, res2, self, eigenvectors, upper);
}
static inline std::tuple<Tensor,Tensor> _th_symeig(const Tensor & self, bool eigenvectors, bool upper) {
    return detail::infer_type(self)._th_symeig(self, eigenvectors, upper);
}
static inline std::tuple<Tensor &,Tensor &> _th_eig_out(Tensor & res1, Tensor & res2, const Tensor & self, bool eigenvectors) {
    return detail::infer_type(self)._th_eig_out(res1, res2, self, eigenvectors);
}
static inline std::tuple<Tensor,Tensor> _th_eig(const Tensor & self, bool eigenvectors) {
    return detail::infer_type(self)._th_eig(self, eigenvectors);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _th_svd_out(Tensor & res1, Tensor & res2, Tensor & res3, const Tensor & self, bool some, bool compute_uv) {
    return detail::infer_type(self)._th_svd_out(res1, res2, res3, self, some, compute_uv);
}
static inline std::tuple<Tensor,Tensor,Tensor> _th_svd(const Tensor & self, bool some, bool compute_uv) {
    return detail::infer_type(self)._th_svd(self, some, compute_uv);
}
static inline Tensor & _th_getri_single_out(Tensor & output, const Tensor & self) {
    return detail::infer_type(self)._th_getri_single_out(output, self);
}
static inline Tensor _th_getri_single(const Tensor & self) {
    return detail::infer_type(self)._th_getri_single(self);
}
static inline Tensor & _th_potrf_single_out(Tensor & output, const Tensor & self, bool upper) {
    return detail::infer_type(self)._th_potrf_single_out(output, self, upper);
}
static inline Tensor _th_potrf_single(const Tensor & self, bool upper) {
    return detail::infer_type(self)._th_potrf_single(self, upper);
}
static inline Tensor & _th_potrs_single_out(Tensor & result, const Tensor & self, const Tensor & input2, bool upper) {
    return detail::infer_type(self)._th_potrs_single_out(result, self, input2, upper);
}
static inline Tensor _th_potrs_single(const Tensor & self, const Tensor & input2, bool upper) {
    return detail::infer_type(self)._th_potrs_single(self, input2, upper);
}
static inline Tensor & _th_potri_out(Tensor & output, const Tensor & self, bool upper) {
    return detail::infer_type(self)._th_potri_out(output, self, upper);
}
static inline Tensor _th_potri(const Tensor & self, bool upper) {
    return detail::infer_type(self)._th_potri(self, upper);
}
static inline std::tuple<Tensor &,Tensor &> _th_pstrf_out(Tensor & res1, Tensor & res2, const Tensor & self, bool upper, Scalar tol) {
    return detail::infer_type(self)._th_pstrf_out(res1, res2, self, upper, tol);
}
static inline std::tuple<Tensor,Tensor> _th_pstrf(const Tensor & self, bool upper, Scalar tol) {
    return detail::infer_type(self)._th_pstrf(self, upper, tol);
}
static inline std::tuple<Tensor &,Tensor &> _th_qr_out(Tensor & res1, Tensor & res2, const Tensor & self) {
    return detail::infer_type(self)._th_qr_out(res1, res2, self);
}
static inline std::tuple<Tensor,Tensor> _th_qr(const Tensor & self) {
    return detail::infer_type(self)._th_qr(self);
}
static inline std::tuple<Tensor &,Tensor &> _th_geqrf_out(Tensor & res1, Tensor & res2, const Tensor & self) {
    return detail::infer_type(self)._th_geqrf_out(res1, res2, self);
}
static inline std::tuple<Tensor,Tensor> _th_geqrf(const Tensor & self) {
    return detail::infer_type(self)._th_geqrf(self);
}
static inline Tensor & _th_orgqr_out(Tensor & result, const Tensor & self, const Tensor & input2) {
    return detail::infer_type(self)._th_orgqr_out(result, self, input2);
}
static inline Tensor _th_orgqr(const Tensor & self, const Tensor & input2) {
    return detail::infer_type(self)._th_orgqr(self, input2);
}
static inline Tensor & _th_ormqr_out(Tensor & result, const Tensor & self, const Tensor & input2, const Tensor & input3, bool left, bool transpose) {
    return detail::infer_type(self)._th_ormqr_out(result, self, input2, input3, left, transpose);
}
static inline Tensor _th_ormqr(const Tensor & self, const Tensor & input2, const Tensor & input3, bool left, bool transpose) {
    return detail::infer_type(self)._th_ormqr(self, input2, input3, left, transpose);
}
static inline std::tuple<Tensor &,Tensor &> _th_btrifact_out(Tensor & result, Tensor & pivots, const Tensor & self, bool pivot) {
    return detail::infer_type(self)._th_btrifact_out(result, pivots, self, pivot);
}
static inline std::tuple<Tensor,Tensor> _th_btrifact(const Tensor & self, bool pivot) {
    return detail::infer_type(self)._th_btrifact(self, pivot);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _th_btrifact_with_info_out(Tensor & result, Tensor & pivots, Tensor & info, const Tensor & self, bool pivot) {
    return detail::infer_type(self)._th_btrifact_with_info_out(result, pivots, info, self, pivot);
}
static inline std::tuple<Tensor,Tensor,Tensor> _th_btrifact_with_info(const Tensor & self, bool pivot) {
    return detail::infer_type(self)._th_btrifact_with_info(self, pivot);
}
static inline Tensor & _th_btrisolve_out(Tensor & result, const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots) {
    return detail::infer_type(self)._th_btrisolve_out(result, self, LU_data, LU_pivots);
}
static inline Tensor _th_btrisolve(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots) {
    return detail::infer_type(self)._th_btrisolve(self, LU_data, LU_pivots);
}
static inline Tensor & _th_random_(Tensor & self, int64_t from, int64_t to, Generator * generator) {
    return detail::infer_type(self)._th_random_(self, from, to, generator);
}
static inline Tensor & _th_random_(Tensor & self, int64_t to, Generator * generator) {
    return detail::infer_type(self)._th_random_(self, to, generator);
}
static inline Tensor & _th_random_(Tensor & self, Generator * generator) {
    return detail::infer_type(self)._th_random_(self, generator);
}
static inline Tensor & _th_multinomial_out(Tensor & result, const Tensor & self, int64_t num_samples, bool replacement, Generator * generator) {
    return detail::infer_type(self)._th_multinomial_out(result, self, num_samples, replacement, generator);
}
static inline Tensor _th_multinomial(const Tensor & self, int64_t num_samples, bool replacement, Generator * generator) {
    return detail::infer_type(self)._th_multinomial(self, num_samples, replacement, generator);
}
static inline Tensor & _th_uniform_(Tensor & self, double from, double to, Generator * generator) {
    return detail::infer_type(self)._th_uniform_(self, from, to, generator);
}
static inline Tensor & _th_normal_out(Tensor & output, const Tensor & mean, double std, Generator * generator) {
    return detail::infer_type(output)._th_normal_out(output, mean, std, generator);
}
static inline Tensor _th_normal(const Tensor & mean, double std, Generator * generator) {
    return detail::infer_type(mean)._th_normal(mean, std, generator);
}
static inline Tensor & _th_normal_out(Tensor & output, double mean, const Tensor & std, Generator * generator) {
    return detail::infer_type(output)._th_normal_out(output, mean, std, generator);
}
static inline Tensor _th_normal(double mean, const Tensor & std, Generator * generator) {
    return detail::infer_type(std)._th_normal(mean, std, generator);
}
static inline Tensor & _th_normal_out(Tensor & output, const Tensor & mean, const Tensor & std, Generator * generator) {
    return detail::infer_type(output)._th_normal_out(output, mean, std, generator);
}
static inline Tensor _th_normal(const Tensor & mean, const Tensor & std, Generator * generator) {
    return detail::infer_type(mean)._th_normal(mean, std, generator);
}
static inline Tensor & _th_normal_(Tensor & self, double mean, double std, Generator * generator) {
    return detail::infer_type(self)._th_normal_(self, mean, std, generator);
}
static inline Tensor & _th_cauchy_(Tensor & self, double median, double sigma, Generator * generator) {
    return detail::infer_type(self)._th_cauchy_(self, median, sigma, generator);
}
static inline Tensor & _th_log_normal_(Tensor & self, double mean, double std, Generator * generator) {
    return detail::infer_type(self)._th_log_normal_(self, mean, std, generator);
}
static inline Tensor & _th_exponential_(Tensor & self, double lambd, Generator * generator) {
    return detail::infer_type(self)._th_exponential_(self, lambd, generator);
}
static inline Tensor & _th_geometric_(Tensor & self, double p, Generator * generator) {
    return detail::infer_type(self)._th_geometric_(self, p, generator);
}
static inline Tensor & _th_dirichlet_grad_out(Tensor & output, const Tensor & x, const Tensor & alpha, const Tensor & total) {
    return detail::infer_type(output)._th_dirichlet_grad_out(output, x, alpha, total);
}
static inline Tensor _th_dirichlet_grad(const Tensor & x, const Tensor & alpha, const Tensor & total) {
    return detail::infer_type(x)._th_dirichlet_grad(x, alpha, total);
}
static inline Tensor _th_alias(const Tensor & self) {
    return detail::infer_type(self)._th_alias(self);
}
static inline Tensor & _th_copy_ignoring_overlaps_(Tensor & self, const Tensor & src) {
    return detail::infer_type(self)._th_copy_ignoring_overlaps_(self, src);
}
static inline Tensor & _th_cat_out(Tensor & self, TensorList tensors, int64_t dim) {
    return detail::infer_type(self)._th_cat_out(self, tensors, dim);
}
static inline Tensor _th_cat(TensorList tensors, int64_t dim) {
    return detail::infer_type(tensors)._th_cat(tensors, dim);
}
static inline Tensor & _thnn_binary_cross_entropy_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_binary_cross_entropy_out(output, self, target, weight, reduction);
}
static inline Tensor _thnn_binary_cross_entropy(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_binary_cross_entropy(self, target, weight, reduction);
}
static inline Tensor & _thnn_binary_cross_entropy_forward_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_binary_cross_entropy_forward_out(output, self, target, weight, reduction);
}
static inline Tensor _thnn_binary_cross_entropy_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_binary_cross_entropy_forward(self, target, weight, reduction);
}
static inline Tensor & _thnn_binary_cross_entropy_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_binary_cross_entropy_backward_out(grad_input, grad_output, self, target, weight, reduction);
}
static inline Tensor _thnn_binary_cross_entropy_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_binary_cross_entropy_backward(grad_output, self, target, weight, reduction);
}
static inline Tensor & _thnn_l1_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_l1_loss_out(output, self, target, reduction);
}
static inline Tensor _thnn_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_l1_loss(self, target, reduction);
}
static inline Tensor & _thnn_l1_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_l1_loss_forward_out(output, self, target, reduction);
}
static inline Tensor _thnn_l1_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_l1_loss_forward(self, target, reduction);
}
static inline Tensor & _thnn_l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_l1_loss_backward_out(grad_input, grad_output, self, target, reduction);
}
static inline Tensor _thnn_l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_l1_loss_backward(grad_output, self, target, reduction);
}
static inline Tensor & _thnn_mse_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_mse_loss_out(output, self, target, reduction);
}
static inline Tensor _thnn_mse_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_mse_loss(self, target, reduction);
}
static inline Tensor & _thnn_mse_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_mse_loss_forward_out(output, self, target, reduction);
}
static inline Tensor _thnn_mse_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_mse_loss_forward(self, target, reduction);
}
static inline Tensor & _thnn_mse_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_mse_loss_backward_out(grad_input, grad_output, self, target, reduction);
}
static inline Tensor _thnn_mse_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_mse_loss_backward(grad_output, self, target, reduction);
}
static inline Tensor & _thnn_multi_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_multi_margin_loss_out(output, self, target, p, margin, weight, reduction);
}
static inline Tensor _thnn_multi_margin_loss(const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_multi_margin_loss(self, target, p, margin, weight, reduction);
}
static inline Tensor & _thnn_multi_margin_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_multi_margin_loss_forward_out(output, self, target, p, margin, weight, reduction);
}
static inline Tensor _thnn_multi_margin_loss_forward(const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_multi_margin_loss_forward(self, target, p, margin, weight, reduction);
}
static inline Tensor & _thnn_multi_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_multi_margin_loss_backward_out(grad_input, grad_output, self, target, p, margin, weight, reduction);
}
static inline Tensor _thnn_multi_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self)._thnn_multi_margin_loss_backward(grad_output, self, target, p, margin, weight, reduction);
}
static inline Tensor & _thnn_multilabel_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_multilabel_margin_loss_out(output, self, target, reduction);
}
static inline Tensor _thnn_multilabel_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_multilabel_margin_loss(self, target, reduction);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_multilabel_margin_loss_forward_out(Tensor & output, Tensor & is_target, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_multilabel_margin_loss_forward_out(output, is_target, self, target, reduction);
}
static inline std::tuple<Tensor,Tensor> _thnn_multilabel_margin_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_multilabel_margin_loss_forward(self, target, reduction);
}
static inline Tensor & _thnn_multilabel_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target) {
    return detail::infer_type(self)._thnn_multilabel_margin_loss_backward_out(grad_input, grad_output, self, target, reduction, is_target);
}
static inline Tensor _thnn_multilabel_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target) {
    return detail::infer_type(self)._thnn_multilabel_margin_loss_backward(grad_output, self, target, reduction, is_target);
}
static inline Tensor & _thnn_nll_loss_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self)._thnn_nll_loss_out(output, self, target, weight, reduction, ignore_index);
}
static inline Tensor _thnn_nll_loss(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self)._thnn_nll_loss(self, target, weight, reduction, ignore_index);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_nll_loss_forward_out(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self)._thnn_nll_loss_forward_out(output, total_weight, self, target, weight, reduction, ignore_index);
}
static inline std::tuple<Tensor,Tensor> _thnn_nll_loss_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self)._thnn_nll_loss_forward(self, target, weight, reduction, ignore_index);
}
static inline Tensor & _thnn_nll_loss_backward_out(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) {
    return detail::infer_type(self)._thnn_nll_loss_backward_out(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight);
}
static inline Tensor _thnn_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) {
    return detail::infer_type(self)._thnn_nll_loss_backward(grad_output, self, target, weight, reduction, ignore_index, total_weight);
}
static inline Tensor & _thnn_nll_loss2d_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self)._thnn_nll_loss2d_out(output, self, target, weight, reduction, ignore_index);
}
static inline Tensor _thnn_nll_loss2d(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self)._thnn_nll_loss2d(self, target, weight, reduction, ignore_index);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_nll_loss2d_forward_out(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self)._thnn_nll_loss2d_forward_out(output, total_weight, self, target, weight, reduction, ignore_index);
}
static inline std::tuple<Tensor,Tensor> _thnn_nll_loss2d_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self)._thnn_nll_loss2d_forward(self, target, weight, reduction, ignore_index);
}
static inline Tensor & _thnn_nll_loss2d_backward_out(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) {
    return detail::infer_type(self)._thnn_nll_loss2d_backward_out(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight);
}
static inline Tensor _thnn_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) {
    return detail::infer_type(self)._thnn_nll_loss2d_backward(grad_output, self, target, weight, reduction, ignore_index, total_weight);
}
static inline Tensor & _thnn_smooth_l1_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_smooth_l1_loss_out(output, self, target, reduction);
}
static inline Tensor _thnn_smooth_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_smooth_l1_loss(self, target, reduction);
}
static inline Tensor & _thnn_smooth_l1_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_smooth_l1_loss_forward_out(output, self, target, reduction);
}
static inline Tensor _thnn_smooth_l1_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_smooth_l1_loss_forward(self, target, reduction);
}
static inline Tensor & _thnn_smooth_l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_smooth_l1_loss_backward_out(grad_input, grad_output, self, target, reduction);
}
static inline Tensor _thnn_smooth_l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_smooth_l1_loss_backward(grad_output, self, target, reduction);
}
static inline Tensor & _thnn_soft_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_soft_margin_loss_out(output, self, target, reduction);
}
static inline Tensor _thnn_soft_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_soft_margin_loss(self, target, reduction);
}
static inline Tensor & _thnn_soft_margin_loss_forward_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_soft_margin_loss_forward_out(output, self, target, reduction);
}
static inline Tensor _thnn_soft_margin_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_soft_margin_loss_forward(self, target, reduction);
}
static inline Tensor & _thnn_soft_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_soft_margin_loss_backward_out(grad_input, grad_output, self, target, reduction);
}
static inline Tensor _thnn_soft_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self)._thnn_soft_margin_loss_backward(grad_output, self, target, reduction);
}
static inline Tensor & _thnn_elu_out(Tensor & output, const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self)._thnn_elu_out(output, self, alpha, scale, input_scale);
}
static inline Tensor _thnn_elu(const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self)._thnn_elu(self, alpha, scale, input_scale);
}
static inline Tensor & _thnn_elu_forward_out(Tensor & output, const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self)._thnn_elu_forward_out(output, self, alpha, scale, input_scale);
}
static inline Tensor _thnn_elu_forward(const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self)._thnn_elu_forward(self, alpha, scale, input_scale);
}
static inline Tensor & _thnn_elu_backward_out(Tensor & grad_input, const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output) {
    return detail::infer_type(grad_input)._thnn_elu_backward_out(grad_input, grad_output, alpha, scale, input_scale, output);
}
static inline Tensor _thnn_elu_backward(const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output) {
    return detail::infer_type(grad_output)._thnn_elu_backward(grad_output, alpha, scale, input_scale, output);
}
static inline Tensor & _thnn_elu_(Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self)._thnn_elu_(self, alpha, scale, input_scale);
}
static inline Tensor & _thnn_elu_forward_(Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self)._thnn_elu_forward_(self, alpha, scale, input_scale);
}
static inline Tensor & _thnn_glu_out(Tensor & output, const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._thnn_glu_out(output, self, dim);
}
static inline Tensor _thnn_glu(const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._thnn_glu(self, dim);
}
static inline Tensor & _thnn_glu_forward_out(Tensor & output, const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._thnn_glu_forward_out(output, self, dim);
}
static inline Tensor _thnn_glu_forward(const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._thnn_glu_forward(self, dim);
}
static inline Tensor & _thnn_glu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._thnn_glu_backward_out(grad_input, grad_output, self, dim);
}
static inline Tensor _thnn_glu_backward(const Tensor & grad_output, const Tensor & self, int64_t dim) {
    return detail::infer_type(self)._thnn_glu_backward(grad_output, self, dim);
}
static inline Tensor & _thnn_hardtanh_out(Tensor & output, const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self)._thnn_hardtanh_out(output, self, min_val, max_val);
}
static inline Tensor _thnn_hardtanh(const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self)._thnn_hardtanh(self, min_val, max_val);
}
static inline Tensor & _thnn_hardtanh_forward_out(Tensor & output, const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self)._thnn_hardtanh_forward_out(output, self, min_val, max_val);
}
static inline Tensor _thnn_hardtanh_forward(const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self)._thnn_hardtanh_forward(self, min_val, max_val);
}
static inline Tensor & _thnn_hardtanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self)._thnn_hardtanh_backward_out(grad_input, grad_output, self, min_val, max_val);
}
static inline Tensor _thnn_hardtanh_backward(const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self)._thnn_hardtanh_backward(grad_output, self, min_val, max_val);
}
static inline Tensor & _thnn_hardtanh_(Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self)._thnn_hardtanh_(self, min_val, max_val);
}
static inline Tensor & _thnn_hardtanh_forward_(Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self)._thnn_hardtanh_forward_(self, min_val, max_val);
}
static inline Tensor & _thnn_leaky_relu_out(Tensor & output, const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self)._thnn_leaky_relu_out(output, self, negative_slope);
}
static inline Tensor _thnn_leaky_relu(const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self)._thnn_leaky_relu(self, negative_slope);
}
static inline Tensor & _thnn_leaky_relu_forward_out(Tensor & output, const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self)._thnn_leaky_relu_forward_out(output, self, negative_slope);
}
static inline Tensor _thnn_leaky_relu_forward(const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self)._thnn_leaky_relu_forward(self, negative_slope);
}
static inline Tensor & _thnn_leaky_relu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self)._thnn_leaky_relu_backward_out(grad_input, grad_output, self, negative_slope);
}
static inline Tensor _thnn_leaky_relu_backward(const Tensor & grad_output, const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self)._thnn_leaky_relu_backward(grad_output, self, negative_slope);
}
static inline Tensor & _thnn_leaky_relu_(Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self)._thnn_leaky_relu_(self, negative_slope);
}
static inline Tensor & _thnn_leaky_relu_forward_(Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self)._thnn_leaky_relu_forward_(self, negative_slope);
}
static inline Tensor & _thnn_log_sigmoid_out(Tensor & output, const Tensor & self) {
    return detail::infer_type(self)._thnn_log_sigmoid_out(output, self);
}
static inline Tensor _thnn_log_sigmoid(const Tensor & self) {
    return detail::infer_type(self)._thnn_log_sigmoid(self);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_log_sigmoid_forward_out(Tensor & output, Tensor & buffer, const Tensor & self) {
    return detail::infer_type(self)._thnn_log_sigmoid_forward_out(output, buffer, self);
}
static inline std::tuple<Tensor,Tensor> _thnn_log_sigmoid_forward(const Tensor & self) {
    return detail::infer_type(self)._thnn_log_sigmoid_forward(self);
}
static inline Tensor & _thnn_log_sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & buffer) {
    return detail::infer_type(self)._thnn_log_sigmoid_backward_out(grad_input, grad_output, self, buffer);
}
static inline Tensor _thnn_log_sigmoid_backward(const Tensor & grad_output, const Tensor & self, const Tensor & buffer) {
    return detail::infer_type(self)._thnn_log_sigmoid_backward(grad_output, self, buffer);
}
static inline Tensor & _thnn_rrelu_with_noise_out(Tensor & output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self)._thnn_rrelu_with_noise_out(output, self, noise, lower, upper, training, generator);
}
static inline Tensor _thnn_rrelu_with_noise(const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self)._thnn_rrelu_with_noise(self, noise, lower, upper, training, generator);
}
static inline Tensor & _thnn_rrelu_with_noise_forward_out(Tensor & output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self)._thnn_rrelu_with_noise_forward_out(output, self, noise, lower, upper, training, generator);
}
static inline Tensor _thnn_rrelu_with_noise_forward(const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self)._thnn_rrelu_with_noise_forward(self, noise, lower, upper, training, generator);
}
static inline Tensor & _thnn_rrelu_with_noise_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training) {
    return detail::infer_type(self)._thnn_rrelu_with_noise_backward_out(grad_input, grad_output, self, noise, lower, upper, training);
}
static inline Tensor _thnn_rrelu_with_noise_backward(const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training) {
    return detail::infer_type(self)._thnn_rrelu_with_noise_backward(grad_output, self, noise, lower, upper, training);
}
static inline Tensor & _thnn_rrelu_with_noise_(Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self)._thnn_rrelu_with_noise_(self, noise, lower, upper, training, generator);
}
static inline Tensor & _thnn_rrelu_with_noise_forward_(Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self)._thnn_rrelu_with_noise_forward_(self, noise, lower, upper, training, generator);
}
static inline Tensor & _thnn_softplus_out(Tensor & output, const Tensor & self, Scalar beta, Scalar threshold) {
    return detail::infer_type(self)._thnn_softplus_out(output, self, beta, threshold);
}
static inline Tensor _thnn_softplus(const Tensor & self, Scalar beta, Scalar threshold) {
    return detail::infer_type(self)._thnn_softplus(self, beta, threshold);
}
static inline Tensor & _thnn_softplus_forward_out(Tensor & output, const Tensor & self, Scalar beta, Scalar threshold) {
    return detail::infer_type(self)._thnn_softplus_forward_out(output, self, beta, threshold);
}
static inline Tensor _thnn_softplus_forward(const Tensor & self, Scalar beta, Scalar threshold) {
    return detail::infer_type(self)._thnn_softplus_forward(self, beta, threshold);
}
static inline Tensor & _thnn_softplus_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output) {
    return detail::infer_type(self)._thnn_softplus_backward_out(grad_input, grad_output, self, beta, threshold, output);
}
static inline Tensor _thnn_softplus_backward(const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output) {
    return detail::infer_type(self)._thnn_softplus_backward(grad_output, self, beta, threshold, output);
}
static inline Tensor & _thnn_softshrink_out(Tensor & output, const Tensor & self, Scalar lambd) {
    return detail::infer_type(self)._thnn_softshrink_out(output, self, lambd);
}
static inline Tensor _thnn_softshrink(const Tensor & self, Scalar lambd) {
    return detail::infer_type(self)._thnn_softshrink(self, lambd);
}
static inline Tensor & _thnn_softshrink_forward_out(Tensor & output, const Tensor & self, Scalar lambd) {
    return detail::infer_type(self)._thnn_softshrink_forward_out(output, self, lambd);
}
static inline Tensor _thnn_softshrink_forward(const Tensor & self, Scalar lambd) {
    return detail::infer_type(self)._thnn_softshrink_forward(self, lambd);
}
static inline Tensor & _thnn_softshrink_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar lambd) {
    return detail::infer_type(self)._thnn_softshrink_backward_out(grad_input, grad_output, self, lambd);
}
static inline Tensor _thnn_softshrink_backward(const Tensor & grad_output, const Tensor & self, Scalar lambd) {
    return detail::infer_type(self)._thnn_softshrink_backward(grad_output, self, lambd);
}
static inline Tensor & _thnn_adaptive_avg_pool2d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool2d_out(output, self, output_size);
}
static inline Tensor _thnn_adaptive_avg_pool2d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool2d(self, output_size);
}
static inline Tensor & _thnn_adaptive_avg_pool2d_forward_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool2d_forward_out(output, self, output_size);
}
static inline Tensor _thnn_adaptive_avg_pool2d_forward(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool2d_forward(self, output_size);
}
static inline Tensor & _thnn_adaptive_avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool2d_backward_out(grad_input, grad_output, self);
}
static inline Tensor _thnn_adaptive_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool2d_backward(grad_output, self);
}
static inline Tensor & _thnn_adaptive_avg_pool3d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool3d_out(output, self, output_size);
}
static inline Tensor _thnn_adaptive_avg_pool3d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool3d(self, output_size);
}
static inline Tensor & _thnn_adaptive_avg_pool3d_forward_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool3d_forward_out(output, self, output_size);
}
static inline Tensor _thnn_adaptive_avg_pool3d_forward(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool3d_forward(self, output_size);
}
static inline Tensor & _thnn_adaptive_avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool3d_backward_out(grad_input, grad_output, self);
}
static inline Tensor _thnn_adaptive_avg_pool3d_backward(const Tensor & grad_output, const Tensor & self) {
    return detail::infer_type(self)._thnn_adaptive_avg_pool3d_backward(grad_output, self);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_adaptive_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_max_pool2d_out(output, indices, self, output_size);
}
static inline std::tuple<Tensor,Tensor> _thnn_adaptive_max_pool2d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_max_pool2d(self, output_size);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_adaptive_max_pool2d_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_max_pool2d_forward_out(output, indices, self, output_size);
}
static inline std::tuple<Tensor,Tensor> _thnn_adaptive_max_pool2d_forward(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_max_pool2d_forward(self, output_size);
}
static inline Tensor & _thnn_adaptive_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
    return detail::infer_type(self)._thnn_adaptive_max_pool2d_backward_out(grad_input, grad_output, self, indices);
}
static inline Tensor _thnn_adaptive_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
    return detail::infer_type(self)._thnn_adaptive_max_pool2d_backward(grad_output, self, indices);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_adaptive_max_pool3d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_max_pool3d_out(output, indices, self, output_size);
}
static inline std::tuple<Tensor,Tensor> _thnn_adaptive_max_pool3d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_max_pool3d(self, output_size);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_adaptive_max_pool3d_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_max_pool3d_forward_out(output, indices, self, output_size);
}
static inline std::tuple<Tensor,Tensor> _thnn_adaptive_max_pool3d_forward(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_adaptive_max_pool3d_forward(self, output_size);
}
static inline Tensor & _thnn_adaptive_max_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
    return detail::infer_type(self)._thnn_adaptive_max_pool3d_backward_out(grad_input, grad_output, self, indices);
}
static inline Tensor _thnn_adaptive_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
    return detail::infer_type(self)._thnn_adaptive_max_pool3d_backward(grad_output, self, indices);
}
static inline Tensor & _thnn_avg_pool2d_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool2d_out(output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor _thnn_avg_pool2d(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor & _thnn_avg_pool2d_forward_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool2d_forward_out(output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor _thnn_avg_pool2d_forward(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool2d_forward(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor & _thnn_avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool2d_backward_out(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor _thnn_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool2d_backward(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor & _thnn_avg_pool3d_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool3d_out(output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor _thnn_avg_pool3d(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor & _thnn_avg_pool3d_forward_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool3d_forward_out(output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor _thnn_avg_pool3d_forward(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool3d_forward(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor & _thnn_avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool3d_backward_out(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor _thnn_avg_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self)._thnn_avg_pool3d_backward(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_fractional_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples) {
    return detail::infer_type(self)._thnn_fractional_max_pool2d_out(output, indices, self, kernel_size, output_size, random_samples);
}
static inline std::tuple<Tensor,Tensor> _thnn_fractional_max_pool2d(const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples) {
    return detail::infer_type(self)._thnn_fractional_max_pool2d(self, kernel_size, output_size, random_samples);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_fractional_max_pool2d_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples) {
    return detail::infer_type(self)._thnn_fractional_max_pool2d_forward_out(output, indices, self, kernel_size, output_size, random_samples);
}
static inline std::tuple<Tensor,Tensor> _thnn_fractional_max_pool2d_forward(const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples) {
    return detail::infer_type(self)._thnn_fractional_max_pool2d_forward(self, kernel_size, output_size, random_samples);
}
static inline Tensor & _thnn_fractional_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & indices) {
    return detail::infer_type(self)._thnn_fractional_max_pool2d_backward_out(grad_input, grad_output, self, kernel_size, output_size, indices);
}
static inline Tensor _thnn_fractional_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & indices) {
    return detail::infer_type(self)._thnn_fractional_max_pool2d_backward(grad_output, self, kernel_size, output_size, indices);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_max_pool2d_with_indices_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self)._thnn_max_pool2d_with_indices_out(output, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline std::tuple<Tensor,Tensor> _thnn_max_pool2d_with_indices(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self)._thnn_max_pool2d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_max_pool2d_with_indices_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self)._thnn_max_pool2d_with_indices_forward_out(output, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline std::tuple<Tensor,Tensor> _thnn_max_pool2d_with_indices_forward(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self)._thnn_max_pool2d_with_indices_forward(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline Tensor & _thnn_max_pool2d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices) {
    return detail::infer_type(self)._thnn_max_pool2d_with_indices_backward_out(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
}
static inline Tensor _thnn_max_pool2d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices) {
    return detail::infer_type(self)._thnn_max_pool2d_with_indices_backward(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_max_pool3d_with_indices_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self)._thnn_max_pool3d_with_indices_out(output, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline std::tuple<Tensor,Tensor> _thnn_max_pool3d_with_indices(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self)._thnn_max_pool3d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_max_pool3d_with_indices_forward_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self)._thnn_max_pool3d_with_indices_forward_out(output, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline std::tuple<Tensor,Tensor> _thnn_max_pool3d_with_indices_forward(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self)._thnn_max_pool3d_with_indices_forward(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline Tensor & _thnn_max_pool3d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices) {
    return detail::infer_type(self)._thnn_max_pool3d_with_indices_backward_out(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
}
static inline Tensor _thnn_max_pool3d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices) {
    return detail::infer_type(self)._thnn_max_pool3d_with_indices_backward(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
}
static inline Tensor & _thnn_max_unpool2d_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self)._thnn_max_unpool2d_out(output, self, indices, output_size);
}
static inline Tensor _thnn_max_unpool2d(const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self)._thnn_max_unpool2d(self, indices, output_size);
}
static inline Tensor & _thnn_max_unpool2d_forward_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self)._thnn_max_unpool2d_forward_out(output, self, indices, output_size);
}
static inline Tensor _thnn_max_unpool2d_forward(const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self)._thnn_max_unpool2d_forward(self, indices, output_size);
}
static inline Tensor & _thnn_max_unpool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self)._thnn_max_unpool2d_backward_out(grad_input, grad_output, self, indices, output_size);
}
static inline Tensor _thnn_max_unpool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self)._thnn_max_unpool2d_backward(grad_output, self, indices, output_size);
}
static inline Tensor & _thnn_max_unpool3d_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_max_unpool3d_out(output, self, indices, output_size, stride, padding);
}
static inline Tensor _thnn_max_unpool3d(const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_max_unpool3d(self, indices, output_size, stride, padding);
}
static inline Tensor & _thnn_max_unpool3d_forward_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_max_unpool3d_forward_out(output, self, indices, output_size, stride, padding);
}
static inline Tensor _thnn_max_unpool3d_forward(const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_max_unpool3d_forward(self, indices, output_size, stride, padding);
}
static inline Tensor & _thnn_max_unpool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_max_unpool3d_backward_out(grad_input, grad_output, self, indices, output_size, stride, padding);
}
static inline Tensor _thnn_max_unpool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_max_unpool3d_backward(grad_output, self, indices, output_size, stride, padding);
}
static inline Tensor & _thnn_reflection_pad1d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad1d_out(output, self, padding);
}
static inline Tensor _thnn_reflection_pad1d(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad1d(self, padding);
}
static inline Tensor & _thnn_reflection_pad1d_forward_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad1d_forward_out(output, self, padding);
}
static inline Tensor _thnn_reflection_pad1d_forward(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad1d_forward(self, padding);
}
static inline Tensor & _thnn_reflection_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad1d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor _thnn_reflection_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad1d_backward(grad_output, self, padding);
}
static inline Tensor & _thnn_reflection_pad2d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad2d_out(output, self, padding);
}
static inline Tensor _thnn_reflection_pad2d(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad2d(self, padding);
}
static inline Tensor & _thnn_reflection_pad2d_forward_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad2d_forward_out(output, self, padding);
}
static inline Tensor _thnn_reflection_pad2d_forward(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad2d_forward(self, padding);
}
static inline Tensor & _thnn_reflection_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad2d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor _thnn_reflection_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_reflection_pad2d_backward(grad_output, self, padding);
}
static inline Tensor & _thnn_replication_pad1d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad1d_out(output, self, padding);
}
static inline Tensor _thnn_replication_pad1d(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad1d(self, padding);
}
static inline Tensor & _thnn_replication_pad1d_forward_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad1d_forward_out(output, self, padding);
}
static inline Tensor _thnn_replication_pad1d_forward(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad1d_forward(self, padding);
}
static inline Tensor & _thnn_replication_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad1d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor _thnn_replication_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad1d_backward(grad_output, self, padding);
}
static inline Tensor & _thnn_replication_pad2d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad2d_out(output, self, padding);
}
static inline Tensor _thnn_replication_pad2d(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad2d(self, padding);
}
static inline Tensor & _thnn_replication_pad2d_forward_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad2d_forward_out(output, self, padding);
}
static inline Tensor _thnn_replication_pad2d_forward(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad2d_forward(self, padding);
}
static inline Tensor & _thnn_replication_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad2d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor _thnn_replication_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad2d_backward(grad_output, self, padding);
}
static inline Tensor & _thnn_replication_pad3d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad3d_out(output, self, padding);
}
static inline Tensor _thnn_replication_pad3d(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad3d(self, padding);
}
static inline Tensor & _thnn_replication_pad3d_forward_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad3d_forward_out(output, self, padding);
}
static inline Tensor _thnn_replication_pad3d_forward(const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad3d_forward(self, padding);
}
static inline Tensor & _thnn_replication_pad3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad3d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor _thnn_replication_pad3d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self)._thnn_replication_pad3d_backward(grad_output, self, padding);
}
static inline Tensor & _thnn_upsample_linear1d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_linear1d_out(output, self, output_size, align_corners);
}
static inline Tensor _thnn_upsample_linear1d(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_linear1d(self, output_size, align_corners);
}
static inline Tensor & _thnn_upsample_linear1d_forward_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_linear1d_forward_out(output, self, output_size, align_corners);
}
static inline Tensor _thnn_upsample_linear1d_forward(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_linear1d_forward(self, output_size, align_corners);
}
static inline Tensor & _thnn_upsample_linear1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_input)._thnn_upsample_linear1d_backward_out(grad_input, grad_output, output_size, input_size, align_corners);
}
static inline Tensor _thnn_upsample_linear1d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_output)._thnn_upsample_linear1d_backward(grad_output, output_size, input_size, align_corners);
}
static inline Tensor & _thnn_upsample_bilinear2d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_bilinear2d_out(output, self, output_size, align_corners);
}
static inline Tensor _thnn_upsample_bilinear2d(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_bilinear2d(self, output_size, align_corners);
}
static inline Tensor & _thnn_upsample_bilinear2d_forward_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_bilinear2d_forward_out(output, self, output_size, align_corners);
}
static inline Tensor _thnn_upsample_bilinear2d_forward(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_bilinear2d_forward(self, output_size, align_corners);
}
static inline Tensor & _thnn_upsample_bilinear2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_input)._thnn_upsample_bilinear2d_backward_out(grad_input, grad_output, output_size, input_size, align_corners);
}
static inline Tensor _thnn_upsample_bilinear2d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_output)._thnn_upsample_bilinear2d_backward(grad_output, output_size, input_size, align_corners);
}
static inline Tensor & _thnn_upsample_trilinear3d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_trilinear3d_out(output, self, output_size, align_corners);
}
static inline Tensor _thnn_upsample_trilinear3d(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_trilinear3d(self, output_size, align_corners);
}
static inline Tensor & _thnn_upsample_trilinear3d_forward_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_trilinear3d_forward_out(output, self, output_size, align_corners);
}
static inline Tensor _thnn_upsample_trilinear3d_forward(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self)._thnn_upsample_trilinear3d_forward(self, output_size, align_corners);
}
static inline Tensor & _thnn_upsample_trilinear3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_input)._thnn_upsample_trilinear3d_backward_out(grad_input, grad_output, output_size, input_size, align_corners);
}
static inline Tensor _thnn_upsample_trilinear3d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_output)._thnn_upsample_trilinear3d_backward(grad_output, output_size, input_size, align_corners);
}
static inline Tensor & _thnn_upsample_nearest1d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest1d_out(output, self, output_size);
}
static inline Tensor _thnn_upsample_nearest1d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest1d(self, output_size);
}
static inline Tensor & _thnn_upsample_nearest1d_forward_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest1d_forward_out(output, self, output_size);
}
static inline Tensor _thnn_upsample_nearest1d_forward(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest1d_forward(self, output_size);
}
static inline Tensor & _thnn_upsample_nearest1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_input)._thnn_upsample_nearest1d_backward_out(grad_input, grad_output, output_size, input_size);
}
static inline Tensor _thnn_upsample_nearest1d_backward(const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_output)._thnn_upsample_nearest1d_backward(grad_output, output_size, input_size);
}
static inline Tensor & _thnn_upsample_nearest2d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest2d_out(output, self, output_size);
}
static inline Tensor _thnn_upsample_nearest2d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest2d(self, output_size);
}
static inline Tensor & _thnn_upsample_nearest2d_forward_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest2d_forward_out(output, self, output_size);
}
static inline Tensor _thnn_upsample_nearest2d_forward(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest2d_forward(self, output_size);
}
static inline Tensor & _thnn_upsample_nearest2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_input)._thnn_upsample_nearest2d_backward_out(grad_input, grad_output, output_size, input_size);
}
static inline Tensor _thnn_upsample_nearest2d_backward(const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_output)._thnn_upsample_nearest2d_backward(grad_output, output_size, input_size);
}
static inline Tensor & _thnn_upsample_nearest3d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest3d_out(output, self, output_size);
}
static inline Tensor _thnn_upsample_nearest3d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest3d(self, output_size);
}
static inline Tensor & _thnn_upsample_nearest3d_forward_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest3d_forward_out(output, self, output_size);
}
static inline Tensor _thnn_upsample_nearest3d_forward(const Tensor & self, IntList output_size) {
    return detail::infer_type(self)._thnn_upsample_nearest3d_forward(self, output_size);
}
static inline Tensor & _thnn_upsample_nearest3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_input)._thnn_upsample_nearest3d_backward_out(grad_input, grad_output, output_size, input_size);
}
static inline Tensor _thnn_upsample_nearest3d_backward(const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_output)._thnn_upsample_nearest3d_backward(grad_output, output_size, input_size);
}
static inline Tensor & _thnn_sigmoid_out(Tensor & output, const Tensor & self) {
    return detail::infer_type(self)._thnn_sigmoid_out(output, self);
}
static inline Tensor _thnn_sigmoid(const Tensor & self) {
    return detail::infer_type(self)._thnn_sigmoid(self);
}
static inline Tensor & _thnn_sigmoid_forward_out(Tensor & output, const Tensor & self) {
    return detail::infer_type(self)._thnn_sigmoid_forward_out(output, self);
}
static inline Tensor _thnn_sigmoid_forward(const Tensor & self) {
    return detail::infer_type(self)._thnn_sigmoid_forward(self);
}
static inline Tensor & _thnn_sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output) {
    return detail::infer_type(grad_input)._thnn_sigmoid_backward_out(grad_input, grad_output, output);
}
static inline Tensor _thnn_sigmoid_backward(const Tensor & grad_output, const Tensor & output) {
    return detail::infer_type(grad_output)._thnn_sigmoid_backward(grad_output, output);
}
static inline Tensor & _thnn_tanh_out(Tensor & output, const Tensor & self) {
    return detail::infer_type(self)._thnn_tanh_out(output, self);
}
static inline Tensor _thnn_tanh(const Tensor & self) {
    return detail::infer_type(self)._thnn_tanh(self);
}
static inline Tensor & _thnn_tanh_forward_out(Tensor & output, const Tensor & self) {
    return detail::infer_type(self)._thnn_tanh_forward_out(output, self);
}
static inline Tensor _thnn_tanh_forward(const Tensor & self) {
    return detail::infer_type(self)._thnn_tanh_forward(self);
}
static inline Tensor & _thnn_tanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output) {
    return detail::infer_type(grad_input)._thnn_tanh_backward_out(grad_input, grad_output, output);
}
static inline Tensor _thnn_tanh_backward(const Tensor & grad_output, const Tensor & output) {
    return detail::infer_type(grad_output)._thnn_tanh_backward(grad_output, output);
}
static inline Tensor & _thnn_conv_transpose2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_transpose2d_out(output, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline Tensor _thnn_conv_transpose2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_transpose2d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_transpose2d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_transpose2d_forward_out(output, columns, ones, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_transpose2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_transpose2d_forward(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_transpose2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & columns, const Tensor & ones) {
    return detail::infer_type(self)._thnn_conv_transpose2d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, columns, ones);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_transpose2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask) {
    return detail::infer_type(self)._thnn_conv_transpose2d_backward(grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, columns, ones, output_mask);
}
static inline Tensor & _thnn_conv_transpose3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_transpose3d_out(output, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline Tensor _thnn_conv_transpose3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_transpose3d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_transpose3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_transpose3d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_transpose3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_transpose3d_forward(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_transpose3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & finput, const Tensor & fgrad_input) {
    return detail::infer_type(self)._thnn_conv_transpose3d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, finput, fgrad_input);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_transpose3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
    return detail::infer_type(self)._thnn_conv_transpose3d_backward(grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, finput, fgrad_input, output_mask);
}
static inline Tensor & _thnn_conv2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_conv2d_out(output, self, weight, kernel_size, bias, stride, padding);
}
static inline Tensor _thnn_conv2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_conv2d(self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv2d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_conv2d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_conv2d_forward(self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input) {
    return detail::infer_type(self)._thnn_conv2d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
    return detail::infer_type(self)._thnn_conv2d_backward(grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input, output_mask);
}
static inline Tensor & _thnn_conv_depthwise2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_depthwise2d_out(output, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor _thnn_conv_depthwise2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_depthwise2d(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor & _thnn_conv_depthwise2d_forward_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_depthwise2d_forward_out(output, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor _thnn_conv_depthwise2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_depthwise2d_forward(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &> _thnn_conv_depthwise2d_backward_out(Tensor & grad_input, Tensor & grad_weight, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_depthwise2d_backward_out(grad_input, grad_weight, grad_output, self, weight, kernel_size, stride, padding, dilation);
}
static inline std::tuple<Tensor,Tensor> _thnn_conv_depthwise2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, std::array<bool,2> output_mask) {
    return detail::infer_type(self)._thnn_conv_depthwise2d_backward(grad_output, self, weight, kernel_size, stride, padding, dilation, output_mask);
}
static inline Tensor & _thnn_conv3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_conv3d_out(output, self, weight, kernel_size, bias, stride, padding);
}
static inline Tensor _thnn_conv3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_conv3d(self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_conv3d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self)._thnn_conv3d_forward(self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input) {
    return detail::infer_type(self)._thnn_conv3d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
    return detail::infer_type(self)._thnn_conv3d_backward(grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input, output_mask);
}
static inline Tensor & _thnn_conv_dilated2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_dilated2d_out(output, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor _thnn_conv_dilated2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_dilated2d(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_dilated2d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_dilated2d_forward_out(output, columns, ones, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_dilated2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_dilated2d_forward(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_dilated2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones) {
    return detail::infer_type(self)._thnn_conv_dilated2d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, dilation, columns, ones);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_dilated2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask) {
    return detail::infer_type(self)._thnn_conv_dilated2d_backward(grad_output, self, weight, kernel_size, stride, padding, dilation, columns, ones, output_mask);
}
static inline Tensor & _thnn_conv_dilated3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_dilated3d_out(output, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor _thnn_conv_dilated3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_dilated3d(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_dilated3d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_dilated3d_forward_out(output, columns, ones, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_dilated3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self)._thnn_conv_dilated3d_forward(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> _thnn_conv_dilated3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones) {
    return detail::infer_type(self)._thnn_conv_dilated3d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, dilation, columns, ones);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_conv_dilated3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask) {
    return detail::infer_type(self)._thnn_conv_dilated3d_backward(grad_output, self, weight, kernel_size, stride, padding, dilation, columns, ones, output_mask);
}
static inline Tensor _cast_Byte(const Tensor & self, bool non_blocking) {
    return detail::infer_type(self)._cast_Byte(self, non_blocking);
}
static inline Tensor _cast_Char(const Tensor & self, bool non_blocking) {
    return detail::infer_type(self)._cast_Char(self, non_blocking);
}
static inline Tensor _cast_Double(const Tensor & self, bool non_blocking) {
    return detail::infer_type(self)._cast_Double(self, non_blocking);
}
static inline Tensor _cast_Float(const Tensor & self, bool non_blocking) {
    return detail::infer_type(self)._cast_Float(self, non_blocking);
}
static inline Tensor _cast_Int(const Tensor & self, bool non_blocking) {
    return detail::infer_type(self)._cast_Int(self, non_blocking);
}
static inline Tensor _cast_Long(const Tensor & self, bool non_blocking) {
    return detail::infer_type(self)._cast_Long(self, non_blocking);
}
static inline Tensor _cast_Short(const Tensor & self, bool non_blocking) {
    return detail::infer_type(self)._cast_Short(self, non_blocking);
}
static inline Tensor _cast_Half(const Tensor & self, bool non_blocking) {
    return detail::infer_type(self)._cast_Half(self, non_blocking);
}
static inline std::tuple<Tensor,Tensor> _cudnn_ctc_loss(const Tensor & log_probs, const Tensor & targets, IntList input_lengths, IntList target_lengths, int64_t blank, bool deterministic) {
    return detail::infer_type(log_probs)._cudnn_ctc_loss(log_probs, targets, input_lengths, target_lengths, blank, deterministic);
}
static inline Tensor _cudnn_rnn_flatten_weight(TensorList weight_arr, int64_t weight_stride0, int64_t input_size, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, bool bidirectional) {
    return detail::infer_type(weight_arr)._cudnn_rnn_flatten_weight(weight_arr, weight_stride0, input_size, mode, hidden_size, num_layers, batch_first, bidirectional);
}
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _cudnn_rnn(const Tensor & input, TensorList weight, int64_t weight_stride0, const Tensor & weight_buf, const Tensor & hx, const Tensor & cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, IntList batch_sizes, const Tensor & dropout_state) {
    return detail::infer_type(input)._cudnn_rnn(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state);
}
static inline std::tuple<Tensor,Tensor,Tensor,std::vector<Tensor>> _cudnn_rnn_backward(const Tensor & input, TensorList weight, int64_t weight_stride0, const Tensor & weight_buf, const Tensor & hx, const Tensor & cx, const Tensor & output, const Tensor & grad_output, const Tensor & grad_hy, const Tensor & grad_cy, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, IntList batch_sizes, const Tensor & dropout_state, const Tensor & reserve, std::array<bool,4> output_mask) {
    return detail::infer_type(input)._cudnn_rnn_backward(input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, reserve, output_mask);
}
static inline Tensor _cudnn_init_dropout_state(double dropout, bool train, int64_t dropout_seed, const TensorOptions & options) {
    return at::getType(options)._cudnn_init_dropout_state(dropout, train, dropout_seed, options);
}
static inline std::tuple<Tensor,Tensor> _fused_dropout(const Tensor & self, double p, Generator * generator) {
    return detail::infer_type(self)._fused_dropout(self, p, generator);
}
static inline Tensor _masked_scale(const Tensor & self, const Tensor & mask, double scale) {
    return detail::infer_type(self)._masked_scale(self, mask, scale);
}
static inline Tensor _reshape_from_tensor(const Tensor & self, const Tensor & shape) {
    return detail::infer_type(self)._reshape_from_tensor(self, shape);
}
static inline Tensor _shape_as_tensor(const Tensor & self) {
    return detail::infer_type(self)._shape_as_tensor(self);
}
static inline Tensor dropout(const Tensor & input, double p, bool train) {
    return detail::infer_type(input).dropout(input, p, train);
}
static inline Tensor & dropout_(Tensor & self, double p, bool train) {
    return detail::infer_type(self).dropout_(self, p, train);
}
static inline Tensor feature_dropout(const Tensor & input, double p, bool train) {
    return detail::infer_type(input).feature_dropout(input, p, train);
}
static inline Tensor & feature_dropout_(Tensor & self, double p, bool train) {
    return detail::infer_type(self).feature_dropout_(self, p, train);
}
static inline Tensor alpha_dropout(const Tensor & input, double p, bool train) {
    return detail::infer_type(input).alpha_dropout(input, p, train);
}
static inline Tensor & alpha_dropout_(Tensor & self, double p, bool train) {
    return detail::infer_type(self).alpha_dropout_(self, p, train);
}
static inline Tensor feature_alpha_dropout(const Tensor & input, double p, bool train) {
    return detail::infer_type(input).feature_alpha_dropout(input, p, train);
}
static inline Tensor & feature_alpha_dropout_(Tensor & self, double p, bool train) {
    return detail::infer_type(self).feature_alpha_dropout_(self, p, train);
}
static inline Tensor abs(const Tensor & self) {
    return detail::infer_type(self).abs(self);
}
static inline Tensor & abs_(Tensor & self) {
    return detail::infer_type(self).abs_(self);
}
static inline Tensor & abs_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).abs_out(result, self);
}
static inline Tensor acos(const Tensor & self) {
    return detail::infer_type(self).acos(self);
}
static inline Tensor & acos_(Tensor & self) {
    return detail::infer_type(self).acos_(self);
}
static inline Tensor & acos_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).acos_out(result, self);
}
static inline Tensor avg_pool1d(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool1d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor adaptive_avg_pool1d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_avg_pool1d(self, output_size);
}
static inline std::tuple<Tensor,Tensor> adaptive_max_pool1d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_max_pool1d(self, output_size);
}
static inline Tensor add(const Tensor & self, const Tensor & other, Scalar alpha) {
    return detail::infer_type(self).add(self, other, alpha);
}
static inline Tensor & add_out(Tensor & result, const Tensor & self, const Tensor & other, Scalar alpha) {
    return detail::infer_type(self).add_out(result, self, other, alpha);
}
static inline Tensor add(const Tensor & self, Scalar other, Scalar alpha) {
    return detail::infer_type(self).add(self, other, alpha);
}
static inline Tensor addmv(const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addmv(self, mat, vec, beta, alpha);
}
static inline Tensor & addmv_(Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addmv_(self, mat, vec, beta, alpha);
}
static inline Tensor & addmv_out(Tensor & result, const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addmv_out(result, self, mat, vec, beta, alpha);
}
static inline Tensor addr(const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addr(self, vec1, vec2, beta, alpha);
}
static inline Tensor & addr_out(Tensor & result, const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addr_out(result, self, vec1, vec2, beta, alpha);
}
static inline Tensor affine_grid_generator(const Tensor & theta, IntList size) {
    return detail::infer_type(theta).affine_grid_generator(theta, size);
}
static inline Tensor affine_grid_generator_backward(const Tensor & grad, IntList size) {
    return detail::infer_type(grad).affine_grid_generator_backward(grad, size);
}
static inline Tensor all(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).all(self, dim, keepdim);
}
static inline Tensor & all_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).all_out(result, self, dim, keepdim);
}
static inline bool allclose(const Tensor & self, const Tensor & other, double rtol, double atol, bool equal_nan) {
    return detail::infer_type(self).allclose(self, other, rtol, atol, equal_nan);
}
static inline Tensor any(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).any(self, dim, keepdim);
}
static inline Tensor & any_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).any_out(result, self, dim, keepdim);
}
static inline Tensor arange(Scalar start, Scalar end, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::arange(start, end, options);
}
static inline Tensor arange(Scalar start, Scalar end, Scalar step, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::arange(start, end, step, options);
}
static inline Tensor & arange_out(Tensor & result, Scalar start, Scalar end) {
    return detail::infer_type(result).arange_out(result, start, end);
}
static inline Tensor & arange_out(Tensor & result, Scalar start, Scalar end, Scalar step) {
    return detail::infer_type(result).arange_out(result, start, end, step);
}
static inline Tensor arange(Scalar end, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::arange(end, options);
}
static inline Tensor & arange_out(Tensor & result, Scalar end) {
    return detail::infer_type(result).arange_out(result, end);
}
static inline Tensor _dim_arange(const Tensor & like, int64_t dim) {
    return detail::infer_type(like)._dim_arange(like, dim);
}
static inline Tensor argmax(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).argmax(self, dim, keepdim);
}
static inline Tensor argmax(const Tensor & self) {
    return detail::infer_type(self).argmax(self);
}
static inline Tensor _argmax(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._argmax(self, dim, keepdim);
}
static inline Tensor argmin(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).argmin(self, dim, keepdim);
}
static inline Tensor argmin(const Tensor & self) {
    return detail::infer_type(self).argmin(self);
}
static inline Tensor _argmin(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self)._argmin(self, dim, keepdim);
}
static inline Tensor as_strided(const Tensor & self, IntList size, IntList stride) {
    return detail::infer_type(self).as_strided(self, size, stride);
}
static inline Tensor & as_strided_(Tensor & self, IntList size, IntList stride) {
    return detail::infer_type(self).as_strided_(self, size, stride);
}
static inline Tensor as_strided(const Tensor & self, IntList size, IntList stride, int64_t storage_offset) {
    return detail::infer_type(self).as_strided(self, size, stride, storage_offset);
}
static inline Tensor & as_strided_(Tensor & self, IntList size, IntList stride, int64_t storage_offset) {
    return detail::infer_type(self).as_strided_(self, size, stride, storage_offset);
}
static inline Tensor asin(const Tensor & self) {
    return detail::infer_type(self).asin(self);
}
static inline Tensor & asin_(Tensor & self) {
    return detail::infer_type(self).asin_(self);
}
static inline Tensor & asin_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).asin_out(result, self);
}
static inline Tensor atan(const Tensor & self) {
    return detail::infer_type(self).atan(self);
}
static inline Tensor & atan_(Tensor & self) {
    return detail::infer_type(self).atan_(self);
}
static inline Tensor & atan_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).atan_out(result, self);
}
static inline Tensor baddbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).baddbmm(self, batch1, batch2, beta, alpha);
}
static inline Tensor & _baddbmm_mkl_(Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._baddbmm_mkl_(self, batch1, batch2, beta, alpha);
}
static inline Tensor & baddbmm_out(Tensor & result, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).baddbmm_out(result, self, batch1, batch2, beta, alpha);
}
static inline Tensor bartlett_window(int64_t window_length, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::bartlett_window(window_length, options);
}
static inline Tensor bartlett_window(int64_t window_length, bool periodic, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::bartlett_window(window_length, periodic, options);
}
static inline Tensor 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, bool cudnn_enabled) {
    return detail::infer_type(input).batch_norm(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled);
}
static inline Tensor bernoulli(const Tensor & self, Generator * generator) {
    return detail::infer_type(self).bernoulli(self, generator);
}
static inline Tensor & bernoulli_out(Tensor & result, const Tensor & self, Generator * generator) {
    return detail::infer_type(self).bernoulli_out(result, self, generator);
}
static inline Tensor bernoulli(const Tensor & self, double p, Generator * generator) {
    return detail::infer_type(self).bernoulli(self, p, generator);
}
static inline Tensor bilinear(const Tensor & input1, const Tensor & input2, const Tensor & weight, const Tensor & bias) {
    return detail::infer_type(input1).bilinear(input1, input2, weight, bias);
}
static inline Tensor binary_cross_entropy_with_logits(const Tensor & self, const Tensor & target, const Tensor & weight, const Tensor & pos_weight, int64_t reduction) {
    return detail::infer_type(self).binary_cross_entropy_with_logits(self, target, weight, pos_weight, reduction);
}
static inline Tensor binary_cross_entropy_with_logits_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, const Tensor & pos_weight, int64_t reduction) {
    return detail::infer_type(self).binary_cross_entropy_with_logits_backward(grad_output, self, target, weight, pos_weight, reduction);
}
static inline Tensor bincount(const Tensor & self, const Tensor & weights, int64_t minlength) {
    return detail::infer_type(self).bincount(self, weights, minlength);
}
static inline Tensor blackman_window(int64_t window_length, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::blackman_window(window_length, options);
}
static inline Tensor blackman_window(int64_t window_length, bool periodic, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::blackman_window(window_length, periodic, options);
}
static inline Tensor bmm(const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self).bmm(self, mat2);
}
static inline Tensor & bmm_out(Tensor & result, const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self).bmm_out(result, self, mat2);
}
static inline std::vector<Tensor> broadcast_tensors(TensorList tensors) {
    return detail::infer_type(tensors).broadcast_tensors(tensors);
}
static inline Tensor cat(TensorList tensors, int64_t dim) {
    return detail::infer_type(tensors).cat(tensors, dim);
}
static inline Tensor & cat_out(Tensor & result, TensorList tensors, int64_t dim) {
    return detail::infer_type(result).cat_out(result, tensors, dim);
}
static inline Tensor ceil(const Tensor & self) {
    return detail::infer_type(self).ceil(self);
}
static inline Tensor & ceil_(Tensor & self) {
    return detail::infer_type(self).ceil_(self);
}
static inline Tensor & ceil_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).ceil_out(result, self);
}
static inline Tensor chain_matmul(TensorList matrices) {
    return detail::infer_type(matrices).chain_matmul(matrices);
}
static inline std::vector<Tensor> chunk(const Tensor & self, int64_t chunks, int64_t dim) {
    return detail::infer_type(self).chunk(self, chunks, dim);
}
static inline Tensor clamp(const Tensor & self, c10::optional<Scalar> min, c10::optional<Scalar> max) {
    return detail::infer_type(self).clamp(self, min, max);
}
static inline Tensor & clamp_(Tensor & self, c10::optional<Scalar> min, c10::optional<Scalar> max) {
    return detail::infer_type(self).clamp_(self, min, max);
}
static inline Tensor & clamp_out(Tensor & result, const Tensor & self, c10::optional<Scalar> min, c10::optional<Scalar> max) {
    return detail::infer_type(self).clamp_out(result, self, min, max);
}
static inline Tensor clamp_max(const Tensor & self, Scalar max) {
    return detail::infer_type(self).clamp_max(self, max);
}
static inline Tensor & clamp_max_(Tensor & self, Scalar max) {
    return detail::infer_type(self).clamp_max_(self, max);
}
static inline Tensor & clamp_max_out(Tensor & result, const Tensor & self, Scalar max) {
    return detail::infer_type(self).clamp_max_out(result, self, max);
}
static inline Tensor clamp_min(const Tensor & self, Scalar min) {
    return detail::infer_type(self).clamp_min(self, min);
}
static inline Tensor & clamp_min_(Tensor & self, Scalar min) {
    return detail::infer_type(self).clamp_min_(self, min);
}
static inline Tensor & clamp_min_out(Tensor & result, const Tensor & self, Scalar min) {
    return detail::infer_type(self).clamp_min_out(result, self, min);
}
static inline bool cudnn_is_acceptable(const Tensor & self) {
    return detail::infer_type(self).cudnn_is_acceptable(self);
}
static inline Tensor constant_pad_nd(const Tensor & self, IntList pad, Scalar value) {
    return detail::infer_type(self).constant_pad_nd(self, pad, value);
}
static inline Tensor convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups) {
    return detail::infer_type(input).convolution(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
}
static inline Tensor _convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled) {
    return detail::infer_type(input)._convolution(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled);
}
static inline Tensor _convolution_nogroup(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding) {
    return detail::infer_type(input)._convolution_nogroup(input, weight, bias, stride, padding, dilation, transposed, output_padding);
}
static inline std::tuple<Tensor,Tensor,Tensor> _convolution_double_backward(const Tensor & ggI, const Tensor & ggW, const Tensor & ggb, const Tensor & gO, const Tensor & weight, const Tensor & self, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, std::array<bool,3> output_mask) {
    return detail::infer_type(self)._convolution_double_backward(ggI, ggW, ggb, gO, weight, self, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, output_mask);
}
static inline Tensor conv1d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, int64_t groups) {
    return detail::infer_type(input).conv1d(input, weight, bias, stride, padding, dilation, groups);
}
static inline Tensor conv2d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, int64_t groups) {
    return detail::infer_type(input).conv2d(input, weight, bias, stride, padding, dilation, groups);
}
static inline Tensor conv3d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList dilation, int64_t groups) {
    return detail::infer_type(input).conv3d(input, weight, bias, stride, padding, dilation, groups);
}
static inline Tensor conv_tbc(const Tensor & self, const Tensor & weight, const Tensor & bias, int64_t pad) {
    return detail::infer_type(self).conv_tbc(self, weight, bias, pad);
}
static inline std::tuple<Tensor,Tensor,Tensor> conv_tbc_backward(const Tensor & self, const Tensor & input, const Tensor & weight, const Tensor & bias, int64_t pad) {
    return detail::infer_type(self).conv_tbc_backward(self, input, weight, bias, pad);
}
static inline Tensor conv_transpose1d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, int64_t groups, IntList dilation) {
    return detail::infer_type(input).conv_transpose1d(input, weight, bias, stride, padding, output_padding, groups, dilation);
}
static inline Tensor conv_transpose2d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, int64_t groups, IntList dilation) {
    return detail::infer_type(input).conv_transpose2d(input, weight, bias, stride, padding, output_padding, groups, dilation);
}
static inline Tensor conv_transpose3d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, int64_t groups, IntList dilation) {
    return detail::infer_type(input).conv_transpose3d(input, weight, bias, stride, padding, output_padding, groups, dilation);
}
static inline Tensor & s_copy_(Tensor & self, const Tensor & src, bool non_blocking) {
    return detail::infer_type(self).s_copy_(self, src, non_blocking);
}
static inline Tensor _s_copy_from(const Tensor & self, const Tensor & dst, bool non_blocking) {
    return detail::infer_type(self)._s_copy_from(self, dst, non_blocking);
}
static inline void _copy_same_type_(Tensor & self, const Tensor & src) {
    return detail::infer_type(self)._copy_same_type_(self, src);
}
static inline Tensor cos(const Tensor & self) {
    return detail::infer_type(self).cos(self);
}
static inline Tensor & cos_(Tensor & self) {
    return detail::infer_type(self).cos_(self);
}
static inline Tensor & cos_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).cos_out(result, self);
}
static inline Tensor cosh(const Tensor & self) {
    return detail::infer_type(self).cosh(self);
}
static inline Tensor & cosh_(Tensor & self) {
    return detail::infer_type(self).cosh_(self);
}
static inline Tensor & cosh_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).cosh_out(result, self);
}
static inline Tensor cosine_embedding_loss(const Tensor & input1, const Tensor & input2, const Tensor & target, double margin, int64_t reduction) {
    return detail::infer_type(input1).cosine_embedding_loss(input1, input2, target, margin, reduction);
}
static inline Tensor cudnn_affine_grid_generator(const Tensor & theta, int64_t N, int64_t C, int64_t H, int64_t W) {
    return detail::infer_type(theta).cudnn_affine_grid_generator(theta, N, C, H, W);
}
static inline Tensor cudnn_affine_grid_generator_backward(const Tensor & grad, int64_t N, int64_t C, int64_t H, int64_t W) {
    return detail::infer_type(grad).cudnn_affine_grid_generator_backward(grad, N, C, H, W);
}
static inline std::tuple<Tensor,Tensor,Tensor> cudnn_batch_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & running_mean, const Tensor & running_var, bool training, double exponential_average_factor, double epsilon) {
    return detail::infer_type(input).cudnn_batch_norm(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon);
}
static inline std::tuple<Tensor,Tensor,Tensor> cudnn_batch_norm_backward(const Tensor & input, const Tensor & grad_output, const Tensor & weight, const Tensor & running_mean, const Tensor & running_var, const Tensor & save_mean, const Tensor & save_var, double epsilon) {
    return detail::infer_type(input).cudnn_batch_norm_backward(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon);
}
static inline Tensor cudnn_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(self).cudnn_convolution(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline Tensor cudnn_convolution_backward_input(IntList self_size, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(grad_output).cudnn_convolution_backward_input(self_size, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline std::tuple<Tensor,Tensor,Tensor> cudnn_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) {
    return detail::infer_type(self).cudnn_convolution_backward(self, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic, output_mask);
}
static inline Tensor cudnn_convolution_backward_bias(const Tensor & grad_output) {
    return detail::infer_type(grad_output).cudnn_convolution_backward_bias(grad_output);
}
static inline Tensor cudnn_convolution_backward_weight(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(self).cudnn_convolution_backward_weight(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline Tensor cudnn_convolution_transpose(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(self).cudnn_convolution_transpose(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic);
}
static inline std::tuple<Tensor,Tensor,Tensor> cudnn_convolution_transpose_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) {
    return detail::infer_type(self).cudnn_convolution_transpose_backward(self, grad_output, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, output_mask);
}
static inline Tensor cudnn_convolution_transpose_backward_bias(const Tensor & grad_output) {
    return detail::infer_type(grad_output).cudnn_convolution_transpose_backward_bias(grad_output);
}
static inline Tensor cudnn_convolution_transpose_backward_input(const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(grad_output).cudnn_convolution_transpose_backward_input(grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline Tensor cudnn_convolution_transpose_backward_weight(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(self).cudnn_convolution_transpose_backward_weight(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline Tensor cudnn_grid_sampler(const Tensor & self, const Tensor & grid) {
    return detail::infer_type(self).cudnn_grid_sampler(self, grid);
}
static inline std::tuple<Tensor,Tensor> cudnn_grid_sampler_backward(const Tensor & self, const Tensor & grid, const Tensor & grad_output) {
    return detail::infer_type(self).cudnn_grid_sampler_backward(self, grid, grad_output);
}
static inline Tensor cumsum(const Tensor & self, int64_t dim, ScalarType dtype) {
    return detail::infer_type(self).cumsum(self, dim, dtype);
}
static inline Tensor cumsum(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).cumsum(self, dim);
}
static inline Tensor & cumsum_out(Tensor & result, const Tensor & self, int64_t dim, ScalarType dtype) {
    return detail::infer_type(self).cumsum_out(result, self, dim, dtype);
}
static inline Tensor & cumsum_out(Tensor & result, const Tensor & self, int64_t dim) {
    return detail::infer_type(self).cumsum_out(result, self, dim);
}
static inline Tensor cumprod(const Tensor & self, int64_t dim, ScalarType dtype) {
    return detail::infer_type(self).cumprod(self, dim, dtype);
}
static inline Tensor cumprod(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).cumprod(self, dim);
}
static inline Tensor & cumprod_out(Tensor & result, const Tensor & self, int64_t dim, ScalarType dtype) {
    return detail::infer_type(self).cumprod_out(result, self, dim, dtype);
}
static inline Tensor & cumprod_out(Tensor & result, const Tensor & self, int64_t dim) {
    return detail::infer_type(self).cumprod_out(result, self, dim);
}
static inline Tensor ctc_loss(const Tensor & log_probs, const Tensor & targets, IntList input_lengths, IntList target_lengths, int64_t blank, int64_t reduction) {
    return detail::infer_type(log_probs).ctc_loss(log_probs, targets, input_lengths, target_lengths, blank, reduction);
}
static inline Tensor ctc_loss(const Tensor & log_probs, const Tensor & targets, const Tensor & input_lengths, const Tensor & target_lengths, int64_t blank, int64_t reduction) {
    return detail::infer_type(log_probs).ctc_loss(log_probs, targets, input_lengths, target_lengths, blank, reduction);
}
static inline std::tuple<Tensor,Tensor> _ctc_loss(const Tensor & log_probs, const Tensor & targets, IntList input_lengths, IntList target_lengths, int64_t blank) {
    return detail::infer_type(log_probs)._ctc_loss(log_probs, targets, input_lengths, target_lengths, blank);
}
static inline Tensor _ctc_loss_backward(const Tensor & grad, const Tensor & log_probs, const Tensor & targets, IntList input_lengths, IntList target_lengths, const Tensor & neg_log_likelihood, const Tensor & log_alpha, int64_t blank) {
    return detail::infer_type(grad)._ctc_loss_backward(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank);
}
static inline Tensor det(const Tensor & self) {
    return detail::infer_type(self).det(self);
}
static inline Tensor diag_embed(const Tensor & self, int64_t offset, int64_t dim1, int64_t dim2) {
    return detail::infer_type(self).diag_embed(self, offset, dim1, dim2);
}
static inline Tensor diagflat(const Tensor & self, int64_t offset) {
    return detail::infer_type(self).diagflat(self, offset);
}
static inline Tensor diagonal(const Tensor & self, int64_t offset, int64_t dim1, int64_t dim2) {
    return detail::infer_type(self).diagonal(self, offset, dim1, dim2);
}
static inline Tensor div(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).div(self, other);
}
static inline Tensor & div_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).div_out(result, self, other);
}
static inline Tensor div(const Tensor & self, Scalar other) {
    return detail::infer_type(self).div(self, other);
}
static inline Tensor dot(const Tensor & self, const Tensor & tensor) {
    return detail::infer_type(self).dot(self, tensor);
}
static inline Tensor & dot_out(Tensor & result, const Tensor & self, const Tensor & tensor) {
    return detail::infer_type(self).dot_out(result, self, tensor);
}
static inline Tensor einsum(std::string equation, TensorList tensors) {
    return detail::infer_type(tensors).einsum(equation, tensors);
}
static inline Tensor embedding(const Tensor & weight, const Tensor & indices, int64_t padding_idx, bool scale_grad_by_freq, bool sparse) {
    return detail::infer_type(weight).embedding(weight, indices, padding_idx, scale_grad_by_freq, sparse);
}
static inline Tensor embedding_backward(const Tensor & grad, const Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq, bool sparse) {
    return detail::infer_type(grad).embedding_backward(grad, indices, num_weights, padding_idx, scale_grad_by_freq, sparse);
}
static inline Tensor embedding_dense_backward(const Tensor & grad, const Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq) {
    return detail::infer_type(grad).embedding_dense_backward(grad, indices, num_weights, padding_idx, scale_grad_by_freq);
}
static inline Tensor & embedding_renorm_(Tensor & self, const Tensor & indices, double max_norm, double norm_type) {
    return detail::infer_type(self).embedding_renorm_(self, indices, max_norm, norm_type);
}
static inline Tensor embedding_sparse_backward(const Tensor & grad, const Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq) {
    return detail::infer_type(grad).embedding_sparse_backward(grad, indices, num_weights, padding_idx, scale_grad_by_freq);
}
static inline 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) {
    return detail::infer_type(weight).embedding_bag(weight, indices, offsets, scale_grad_by_freq, mode, sparse);
}
static inline 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) {
    return detail::infer_type(weight)._embedding_bag(weight, indices, offsets, scale_grad_by_freq, mode, sparse);
}
static inline Tensor _embedding_bag_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, bool sparse) {
    return detail::infer_type(grad)._embedding_bag_backward(grad, indices, offsets, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, sparse);
}
static inline Tensor _embedding_bag_sparse_backward(const Tensor & grad, const Tensor & indices, const Tensor & offsets, const Tensor & offset2bag, const Tensor & bag_size, int64_t num_weights, bool scale_grad_by_freq, int64_t mode) {
    return detail::infer_type(grad)._embedding_bag_sparse_backward(grad, indices, offsets, offset2bag, bag_size, num_weights, scale_grad_by_freq, mode);
}
static inline 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) {
    return detail::infer_type(grad)._embedding_bag_dense_backward(grad, indices, offsets, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode);
}
static inline Tensor empty(IntList size, const TensorOptions & options) {
    return at::getType(options).empty(size, options);
}
static inline Tensor & empty_out(Tensor & result, IntList size) {
    return detail::infer_type(result).empty_out(result, size);
}
static inline Tensor empty_like(const Tensor & self) {
    return detail::infer_type(self).empty_like(self);
}
static inline Tensor empty_like(const Tensor & self, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::empty_like(self, options);
}
static inline Tensor empty_strided(IntList size, IntList stride, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::empty_strided(size, stride, options);
}
static inline Tensor erf(const Tensor & self) {
    return detail::infer_type(self).erf(self);
}
static inline Tensor & erf_(Tensor & self) {
    return detail::infer_type(self).erf_(self);
}
static inline Tensor & erf_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).erf_out(result, self);
}
static inline Tensor erfc(const Tensor & self) {
    return detail::infer_type(self).erfc(self);
}
static inline Tensor & erfc_(Tensor & self) {
    return detail::infer_type(self).erfc_(self);
}
static inline Tensor & erfc_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).erfc_out(result, self);
}
static inline Tensor exp(const Tensor & self) {
    return detail::infer_type(self).exp(self);
}
static inline Tensor & exp_(Tensor & self) {
    return detail::infer_type(self).exp_(self);
}
static inline Tensor & exp_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).exp_out(result, self);
}
static inline Tensor expm1(const Tensor & self) {
    return detail::infer_type(self).expm1(self);
}
static inline Tensor & expm1_(Tensor & self) {
    return detail::infer_type(self).expm1_(self);
}
static inline Tensor & expm1_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).expm1_out(result, self);
}
static inline Tensor eye(int64_t n, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::eye(n, options);
}
static inline Tensor eye(int64_t n, int64_t m, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::eye(n, m, options);
}
static inline Tensor & eye_out(Tensor & result, int64_t n) {
    return detail::infer_type(result).eye_out(result, n);
}
static inline Tensor & eye_out(Tensor & result, int64_t n, int64_t m) {
    return detail::infer_type(result).eye_out(result, n, m);
}
static inline Tensor flatten(const Tensor & self, int64_t start_dim, int64_t end_dim) {
    return detail::infer_type(self).flatten(self, start_dim, end_dim);
}
static inline Tensor & fill_(Tensor & self, Scalar value) {
    return detail::infer_type(self).fill_(self, value);
}
static inline Tensor & fill_(Tensor & self, const Tensor & value) {
    return detail::infer_type(self).fill_(self, value);
}
static inline Tensor floor(const Tensor & self) {
    return detail::infer_type(self).floor(self);
}
static inline Tensor & floor_(Tensor & self) {
    return detail::infer_type(self).floor_(self);
}
static inline Tensor & floor_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).floor_out(result, self);
}
static inline Tensor full(IntList size, Scalar fill_value, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::full(size, fill_value, options);
}
static inline Tensor & full_out(Tensor & result, IntList size, Scalar fill_value) {
    return detail::infer_type(result).full_out(result, size, fill_value);
}
static inline Tensor full_like(const Tensor & self, Scalar fill_value) {
    return detail::infer_type(self).full_like(self, fill_value);
}
static inline Tensor full_like(const Tensor & self, Scalar fill_value, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::full_like(self, fill_value, options);
}
static inline Tensor grid_sampler(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode) {
    return detail::infer_type(input).grid_sampler(input, grid, interpolation_mode, padding_mode);
}
static inline Tensor grid_sampler_2d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode) {
    return detail::infer_type(input).grid_sampler_2d(input, grid, interpolation_mode, padding_mode);
}
static inline 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) {
    return detail::infer_type(grad_output).grid_sampler_2d_backward(grad_output, input, grid, interpolation_mode, padding_mode);
}
static inline Tensor grid_sampler_3d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode) {
    return detail::infer_type(input).grid_sampler_3d(input, grid, interpolation_mode, padding_mode);
}
static inline 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) {
    return detail::infer_type(grad_output).grid_sampler_3d_backward(grad_output, input, grid, interpolation_mode, padding_mode);
}
static inline Tensor hann_window(int64_t window_length, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::hann_window(window_length, options);
}
static inline Tensor hann_window(int64_t window_length, bool periodic, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::hann_window(window_length, periodic, options);
}
static inline Tensor hamming_window(int64_t window_length, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::hamming_window(window_length, options);
}
static inline Tensor hamming_window(int64_t window_length, bool periodic, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::hamming_window(window_length, periodic, options);
}
static inline Tensor hamming_window(int64_t window_length, bool periodic, double alpha, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::hamming_window(window_length, periodic, alpha, options);
}
static inline Tensor hamming_window(int64_t window_length, bool periodic, double alpha, double beta, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::hamming_window(window_length, periodic, alpha, beta, options);
}
static inline Tensor hinge_embedding_loss(const Tensor & self, const Tensor & target, double margin, int64_t reduction) {
    return detail::infer_type(self).hinge_embedding_loss(self, target, margin, reduction);
}
static inline Tensor ger(const Tensor & self, const Tensor & vec2) {
    return detail::infer_type(self).ger(self, vec2);
}
static inline Tensor & ger_out(Tensor & result, const Tensor & self, const Tensor & vec2) {
    return detail::infer_type(self).ger_out(result, self, vec2);
}
static inline std::tuple<Tensor,Tensor> gesv(const Tensor & self, const Tensor & A) {
    return detail::infer_type(self).gesv(self, A);
}
static inline std::tuple<Tensor &,Tensor &> gesv_out(Tensor & solution, Tensor & lu, const Tensor & self, const Tensor & A) {
    return detail::infer_type(self).gesv_out(solution, lu, self, A);
}
static inline std::tuple<Tensor,Tensor> _gesv_helper(const Tensor & self, const Tensor & A) {
    return detail::infer_type(self)._gesv_helper(self, A);
}
static inline Tensor group_norm(const Tensor & input, int64_t num_groups, const Tensor & weight, const Tensor & bias, double eps, bool cudnn_enabled) {
    return detail::infer_type(input).group_norm(input, num_groups, weight, bias, eps, cudnn_enabled);
}
static inline Tensor fft(const Tensor & self, int64_t signal_ndim, bool normalized) {
    return detail::infer_type(self).fft(self, signal_ndim, normalized);
}
static inline Tensor ifft(const Tensor & self, int64_t signal_ndim, bool normalized) {
    return detail::infer_type(self).ifft(self, signal_ndim, normalized);
}
static inline Tensor rfft(const Tensor & self, int64_t signal_ndim, bool normalized, bool onesided) {
    return detail::infer_type(self).rfft(self, signal_ndim, normalized, onesided);
}
static inline Tensor irfft(const Tensor & self, int64_t signal_ndim, bool normalized, bool onesided, IntList signal_sizes) {
    return detail::infer_type(self).irfft(self, signal_ndim, normalized, onesided, signal_sizes);
}
static inline Tensor _fft_with_size(const Tensor & self, int64_t signal_ndim, bool complex_input, bool complex_output, bool inverse, IntList checked_signal_sizes, bool normalized, bool onesided, IntList output_sizes) {
    return detail::infer_type(self)._fft_with_size(self, signal_ndim, complex_input, complex_output, inverse, checked_signal_sizes, normalized, onesided, output_sizes);
}
static inline int64_t _cufft_get_plan_cache_size() {
    return at::getNonVariableType(at::Backend::Undefined, at::ScalarType::Float)._cufft_get_plan_cache_size();
}
static inline int64_t _cufft_get_plan_cache_max_size() {
    return at::getNonVariableType(at::Backend::Undefined, at::ScalarType::Float)._cufft_get_plan_cache_max_size();
}
static inline void _cufft_set_plan_cache_max_size(int64_t max_size) {
    return at::getNonVariableType(at::Backend::Undefined, at::ScalarType::Float)._cufft_set_plan_cache_max_size(max_size);
}
static inline void _cufft_clear_plan_cache() {
    return at::getNonVariableType(at::Backend::Undefined, at::ScalarType::Float)._cufft_clear_plan_cache();
}
static inline Tensor index(const Tensor & self, TensorList indices) {
    return detail::infer_type(self).index(self, indices);
}
static inline Tensor index_put(const Tensor & self, TensorList indices, const Tensor & values, bool accumulate) {
    return detail::infer_type(self).index_put(self, indices, values, accumulate);
}
static inline Tensor & index_put_(Tensor & self, TensorList indices, const Tensor & values, bool accumulate) {
    return detail::infer_type(self).index_put_(self, indices, values, accumulate);
}
static inline Tensor instance_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & running_mean, const Tensor & running_var, bool use_input_stats, double momentum, double eps, bool cudnn_enabled) {
    return detail::infer_type(input).instance_norm(input, weight, bias, running_mean, running_var, use_input_stats, momentum, eps, cudnn_enabled);
}
static inline Tensor inverse(const Tensor & self) {
    return detail::infer_type(self).inverse(self);
}
static inline Tensor & inverse_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).inverse_out(result, self);
}
static inline Tensor _inverse_helper(const Tensor & self) {
    return detail::infer_type(self)._inverse_helper(self);
}
static inline Tensor isclose(const Tensor & self, const Tensor & other, double rtol, double atol, bool equal_nan) {
    return detail::infer_type(self).isclose(self, other, rtol, atol, equal_nan);
}
static inline bool is_distributed(const Tensor & self) {
    return detail::infer_type(self).is_distributed(self);
}
static inline bool is_floating_point(const Tensor & self) {
    return detail::infer_type(self).is_floating_point(self);
}
static inline bool is_complex(const Tensor & self) {
    return detail::infer_type(self).is_complex(self);
}
static inline bool is_nonzero(const Tensor & self) {
    return detail::infer_type(self).is_nonzero(self);
}
static inline bool is_same_size(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).is_same_size(self, other);
}
static inline bool is_signed(const Tensor & self) {
    return detail::infer_type(self).is_signed(self);
}
static inline Tensor kl_div(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).kl_div(self, target, reduction);
}
static inline Tensor kl_div_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).kl_div_backward(grad_output, self, target, reduction);
}
static inline std::tuple<Tensor,Tensor> kthvalue(const Tensor & self, int64_t k, int64_t dim, bool keepdim) {
    return detail::infer_type(self).kthvalue(self, k, dim, keepdim);
}
static inline std::tuple<Tensor &,Tensor &> kthvalue_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim, bool keepdim) {
    return detail::infer_type(self).kthvalue_out(values, indices, self, k, dim, keepdim);
}
static inline Tensor layer_norm(const Tensor & input, IntList normalized_shape, const Tensor & weight, const Tensor & bias, double eps, bool cudnn_enable) {
    return detail::infer_type(input).layer_norm(input, normalized_shape, weight, bias, eps, cudnn_enable);
}
static inline Tensor linear(const Tensor & input, const Tensor & weight, const Tensor & bias) {
    return detail::infer_type(input).linear(input, weight, bias);
}
static inline Tensor linspace(Scalar start, Scalar end, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::linspace(start, end, options);
}
static inline Tensor linspace(Scalar start, Scalar end, int64_t steps, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::linspace(start, end, steps, options);
}
static inline Tensor & linspace_out(Tensor & result, Scalar start, Scalar end) {
    return detail::infer_type(result).linspace_out(result, start, end);
}
static inline Tensor & linspace_out(Tensor & result, Scalar start, Scalar end, int64_t steps) {
    return detail::infer_type(result).linspace_out(result, start, end, steps);
}
static inline Tensor log(const Tensor & self) {
    return detail::infer_type(self).log(self);
}
static inline Tensor & log_(Tensor & self) {
    return detail::infer_type(self).log_(self);
}
static inline Tensor & log_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).log_out(result, self);
}
static inline Tensor log10(const Tensor & self) {
    return detail::infer_type(self).log10(self);
}
static inline Tensor & log10_(Tensor & self) {
    return detail::infer_type(self).log10_(self);
}
static inline Tensor & log10_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).log10_out(result, self);
}
static inline Tensor log1p(const Tensor & self) {
    return detail::infer_type(self).log1p(self);
}
static inline Tensor & log1p_(Tensor & self) {
    return detail::infer_type(self).log1p_(self);
}
static inline Tensor & log1p_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).log1p_out(result, self);
}
static inline Tensor log2(const Tensor & self) {
    return detail::infer_type(self).log2(self);
}
static inline Tensor & log2_(Tensor & self) {
    return detail::infer_type(self).log2_(self);
}
static inline Tensor & log2_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).log2_out(result, self);
}
static inline Tensor logdet(const Tensor & self) {
    return detail::infer_type(self).logdet(self);
}
static inline Tensor logspace(Scalar start, Scalar end, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::logspace(start, end, options);
}
static inline Tensor logspace(Scalar start, Scalar end, int64_t steps, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::logspace(start, end, steps, options);
}
static inline Tensor & logspace_out(Tensor & result, Scalar start, Scalar end) {
    return detail::infer_type(result).logspace_out(result, start, end);
}
static inline Tensor & logspace_out(Tensor & result, Scalar start, Scalar end, int64_t steps) {
    return detail::infer_type(result).logspace_out(result, start, end, steps);
}
static inline Tensor log_softmax(const Tensor & self, int64_t dim, ScalarType dtype) {
    return detail::infer_type(self).log_softmax(self, dim, dtype);
}
static inline Tensor log_softmax(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).log_softmax(self, dim);
}
static inline Tensor _log_softmax(const Tensor & self, int64_t dim, bool half_to_float) {
    return detail::infer_type(self)._log_softmax(self, dim, half_to_float);
}
static inline Tensor _log_softmax_backward_data(const Tensor & grad_output, const Tensor & output, int64_t dim, const Tensor & self) {
    return detail::infer_type(self)._log_softmax_backward_data(grad_output, output, dim, self);
}
static inline Tensor logsumexp(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).logsumexp(self, dim, keepdim);
}
static inline Tensor & logsumexp_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).logsumexp_out(result, self, dim, keepdim);
}
static inline Tensor margin_ranking_loss(const Tensor & input1, const Tensor & input2, const Tensor & target, double margin, int64_t reduction) {
    return detail::infer_type(input1).margin_ranking_loss(input1, input2, target, margin, reduction);
}
static inline Tensor matmul(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).matmul(self, other);
}
static inline Tensor & matmul_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).matmul_out(result, self, other);
}
static inline Tensor matrix_rank(const Tensor & self, double tol, bool symmetric) {
    return detail::infer_type(self).matrix_rank(self, tol, symmetric);
}
static inline Tensor matrix_rank(const Tensor & self, bool symmetric) {
    return detail::infer_type(self).matrix_rank(self, symmetric);
}
static inline Tensor matrix_power(const Tensor & self, int64_t n) {
    return detail::infer_type(self).matrix_power(self, n);
}
static inline std::tuple<Tensor,Tensor> max(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).max(self, dim, keepdim);
}
static inline std::tuple<Tensor &,Tensor &> max_out(Tensor & max, Tensor & max_values, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).max_out(max, max_values, self, dim, keepdim);
}
static inline Tensor max_values(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).max_values(self, dim, keepdim);
}
static inline std::tuple<Tensor,Tensor> max_pool1d_with_indices(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self).max_pool1d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline Tensor max_pool1d(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self).max_pool1d(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline Tensor max_pool2d(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self).max_pool2d(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline Tensor max_pool3d(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self).max_pool3d(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline Tensor mean(const Tensor & self, ScalarType dtype) {
    return detail::infer_type(self).mean(self, dtype);
}
static inline Tensor mean(const Tensor & self) {
    return detail::infer_type(self).mean(self);
}
static inline Tensor mean(const Tensor & self, IntList dim, bool keepdim, ScalarType dtype) {
    return detail::infer_type(self).mean(self, dim, keepdim, dtype);
}
static inline Tensor mean(const Tensor & self, IntList dim, bool keepdim) {
    return detail::infer_type(self).mean(self, dim, keepdim);
}
static inline Tensor mean(const Tensor & self, IntList dim, ScalarType dtype) {
    return detail::infer_type(self).mean(self, dim, dtype);
}
static inline Tensor & mean_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim, ScalarType dtype) {
    return detail::infer_type(self).mean_out(result, self, dim, keepdim, dtype);
}
static inline Tensor & mean_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim) {
    return detail::infer_type(self).mean_out(result, self, dim, keepdim);
}
static inline Tensor & mean_out(Tensor & result, const Tensor & self, IntList dim, ScalarType dtype) {
    return detail::infer_type(self).mean_out(result, self, dim, dtype);
}
static inline std::tuple<Tensor,Tensor> median(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).median(self, dim, keepdim);
}
static inline std::tuple<Tensor &,Tensor &> median_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).median_out(values, indices, self, dim, keepdim);
}
static inline std::tuple<Tensor,Tensor> min(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).min(self, dim, keepdim);
}
static inline std::tuple<Tensor &,Tensor &> min_out(Tensor & min, Tensor & min_indices, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).min_out(min, min_indices, self, dim, keepdim);
}
static inline Tensor min_values(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).min_values(self, dim, keepdim);
}
static inline Tensor mkldnn_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList stride, IntList dilation, int64_t groups) {
    return detail::infer_type(self).mkldnn_convolution(self, weight, bias, padding, stride, dilation, groups);
}
static inline Tensor mkldnn_convolution_backward_input(IntList self_size, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool bias_defined) {
    return detail::infer_type(grad_output).mkldnn_convolution_backward_input(self_size, grad_output, weight, padding, stride, dilation, groups, bias_defined);
}
static inline std::tuple<Tensor,Tensor> mkldnn_convolution_backward_weights(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool bias_defined) {
    return detail::infer_type(self).mkldnn_convolution_backward_weights(weight_size, grad_output, self, padding, stride, dilation, groups, bias_defined);
}
static inline std::tuple<Tensor,Tensor,Tensor> mkldnn_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, std::array<bool,3> output_mask) {
    return detail::infer_type(self).mkldnn_convolution_backward(self, grad_output, weight, padding, stride, dilation, groups, output_mask);
}
static inline std::tuple<Tensor,Tensor,Tensor> miopen_batch_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & running_mean, const Tensor & running_var, bool training, double exponential_average_factor, double epsilon) {
    return detail::infer_type(input).miopen_batch_norm(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon);
}
static inline std::tuple<Tensor,Tensor,Tensor> miopen_batch_norm_backward(const Tensor & input, const Tensor & grad_output, const Tensor & weight, const Tensor & running_mean, const Tensor & running_var, const Tensor & save_mean, const Tensor & save_var, double epsilon) {
    return detail::infer_type(input).miopen_batch_norm_backward(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon);
}
static inline Tensor miopen_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(self).miopen_convolution(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline Tensor miopen_convolution_backward_input(IntList self_size, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(grad_output).miopen_convolution_backward_input(self_size, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline std::tuple<Tensor,Tensor,Tensor> miopen_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) {
    return detail::infer_type(self).miopen_convolution_backward(self, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic, output_mask);
}
static inline Tensor miopen_convolution_backward_bias(const Tensor & grad_output) {
    return detail::infer_type(grad_output).miopen_convolution_backward_bias(grad_output);
}
static inline Tensor miopen_convolution_backward_weight(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(self).miopen_convolution_backward_weight(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline Tensor miopen_convolution_transpose(const Tensor & self, const Tensor & weight, const Tensor & bias, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(self).miopen_convolution_transpose(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic);
}
static inline std::tuple<Tensor,Tensor,Tensor> miopen_convolution_transpose_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) {
    return detail::infer_type(self).miopen_convolution_transpose_backward(self, grad_output, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, output_mask);
}
static inline Tensor miopen_convolution_transpose_backward_input(const Tensor & grad_output, const Tensor & weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(grad_output).miopen_convolution_transpose_backward_input(grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline Tensor miopen_convolution_transpose_backward_weight(IntList weight_size, const Tensor & grad_output, const Tensor & self, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic) {
    return detail::infer_type(self).miopen_convolution_transpose_backward_weight(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
}
static inline Tensor mm(const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self).mm(self, mat2);
}
static inline Tensor & mm_out(Tensor & result, const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self).mm_out(result, self, mat2);
}
static inline Tensor _sparse_mm(const Tensor & sparse, const Tensor & dense) {
    return detail::infer_type(sparse)._sparse_mm(sparse, dense);
}
static inline std::tuple<Tensor,Tensor> mode(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).mode(self, dim, keepdim);
}
static inline std::tuple<Tensor &,Tensor &> mode_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).mode_out(values, indices, self, dim, keepdim);
}
static inline Tensor mul(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).mul(self, other);
}
static inline Tensor & mul_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).mul_out(result, self, other);
}
static inline Tensor mul(const Tensor & self, Scalar other) {
    return detail::infer_type(self).mul(self, other);
}
static inline Tensor mv(const Tensor & self, const Tensor & vec) {
    return detail::infer_type(self).mv(self, vec);
}
static inline Tensor & mv_out(Tensor & result, const Tensor & self, const Tensor & vec) {
    return detail::infer_type(self).mv_out(result, self, vec);
}
static inline Tensor mvlgamma(const Tensor & self, int64_t p) {
    return detail::infer_type(self).mvlgamma(self, p);
}
static inline Tensor narrow(const Tensor & self, int64_t dim, int64_t start, int64_t length) {
    return detail::infer_type(self).narrow(self, dim, start, length);
}
static inline 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) {
    return detail::infer_type(input).native_batch_norm(input, weight, bias, running_mean, running_var, training, momentum, eps);
}
static inline 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) {
    return detail::infer_type(grad_out).native_batch_norm_backward(grad_out, input, weight, running_mean, running_var, save_mean, save_invstd, train, eps, output_mask);
}
static inline Tensor ones(IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::ones(size, options);
}
static inline Tensor & ones_out(Tensor & result, IntList size) {
    return detail::infer_type(result).ones_out(result, size);
}
static inline Tensor ones_like(const Tensor & self) {
    return detail::infer_type(self).ones_like(self);
}
static inline Tensor ones_like(const Tensor & self, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::ones_like(self, options);
}
static inline Tensor pairwise_distance(const Tensor & x1, const Tensor & x2, double p, double eps, bool keepdim) {
    return detail::infer_type(x1).pairwise_distance(x1, x2, p, eps, keepdim);
}
static inline Tensor pdist(const Tensor & self, double p) {
    return detail::infer_type(self).pdist(self, p);
}
static inline Tensor _pdist_forward(const Tensor & self, double p) {
    return detail::infer_type(self)._pdist_forward(self, p);
}
static inline Tensor _pdist_backward(const Tensor & grad, const Tensor & self, double p, const Tensor & pdist) {
    return detail::infer_type(self)._pdist_backward(grad, self, p, pdist);
}
static inline Tensor cosine_similarity(const Tensor & x1, const Tensor & x2, int64_t dim, double eps) {
    return detail::infer_type(x1).cosine_similarity(x1, x2, dim, eps);
}
static inline Tensor pixel_shuffle(const Tensor & self, int64_t upscale_factor) {
    return detail::infer_type(self).pixel_shuffle(self, upscale_factor);
}
static inline Tensor pin_memory(const Tensor & self) {
    return detail::infer_type(self).pin_memory(self);
}
static inline Tensor pinverse(const Tensor & self, double rcond) {
    return detail::infer_type(self).pinverse(self, rcond);
}
static inline Tensor rand(IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::rand(size, options);
}
static inline Tensor rand(IntList size, Generator * generator, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::rand(size, generator, options);
}
static inline Tensor & rand_out(Tensor & result, IntList size) {
    return detail::infer_type(result).rand_out(result, size);
}
static inline Tensor & rand_out(Tensor & result, IntList size, Generator * generator) {
    return detail::infer_type(result).rand_out(result, size, generator);
}
static inline Tensor rand_like(const Tensor & self) {
    return detail::infer_type(self).rand_like(self);
}
static inline Tensor rand_like(const Tensor & self, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::rand_like(self, options);
}
static inline Tensor randint(int64_t high, IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randint(high, size, options);
}
static inline Tensor randint(int64_t high, IntList size, Generator * generator, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randint(high, size, generator, options);
}
static inline Tensor randint(int64_t low, int64_t high, IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randint(low, high, size, options);
}
static inline Tensor randint(int64_t low, int64_t high, IntList size, Generator * generator, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randint(low, high, size, generator, options);
}
static inline Tensor & randint_out(Tensor & result, int64_t high, IntList size) {
    return detail::infer_type(result).randint_out(result, high, size);
}
static inline Tensor & randint_out(Tensor & result, int64_t high, IntList size, Generator * generator) {
    return detail::infer_type(result).randint_out(result, high, size, generator);
}
static inline Tensor & randint_out(Tensor & result, int64_t low, int64_t high, IntList size) {
    return detail::infer_type(result).randint_out(result, low, high, size);
}
static inline Tensor & randint_out(Tensor & result, int64_t low, int64_t high, IntList size, Generator * generator) {
    return detail::infer_type(result).randint_out(result, low, high, size, generator);
}
static inline Tensor randint_like(const Tensor & self, int64_t high) {
    return detail::infer_type(self).randint_like(self, high);
}
static inline Tensor randint_like(const Tensor & self, int64_t low, int64_t high) {
    return detail::infer_type(self).randint_like(self, low, high);
}
static inline Tensor randint_like(const Tensor & self, int64_t high, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randint_like(self, high, options);
}
static inline Tensor randint_like(const Tensor & self, int64_t low, int64_t high, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randint_like(self, low, high, options);
}
static inline Tensor randn(IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randn(size, options);
}
static inline Tensor randn(IntList size, Generator * generator, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randn(size, generator, options);
}
static inline Tensor & randn_out(Tensor & result, IntList size) {
    return detail::infer_type(result).randn_out(result, size);
}
static inline Tensor & randn_out(Tensor & result, IntList size, Generator * generator) {
    return detail::infer_type(result).randn_out(result, size, generator);
}
static inline Tensor randn_like(const Tensor & self) {
    return detail::infer_type(self).randn_like(self);
}
static inline Tensor randn_like(const Tensor & self, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randn_like(self, options);
}
static inline Tensor randperm(int64_t n, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randperm(n, options);
}
static inline Tensor randperm(int64_t n, Generator * generator, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::randperm(n, generator, options);
}
static inline Tensor & randperm_out(Tensor & result, int64_t n) {
    return detail::infer_type(result).randperm_out(result, n);
}
static inline Tensor & randperm_out(Tensor & result, int64_t n, Generator * generator) {
    return detail::infer_type(result).randperm_out(result, n, generator);
}
static inline Tensor range(Scalar start, Scalar end, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::range(start, end, options);
}
static inline Tensor range(Scalar start, Scalar end, Scalar step, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::range(start, end, step, options);
}
static inline Tensor & range_out(Tensor & result, Scalar start, Scalar end) {
    return detail::infer_type(result).range_out(result, start, end);
}
static inline Tensor & range_out(Tensor & result, Scalar start, Scalar end, Scalar step) {
    return detail::infer_type(result).range_out(result, start, end, step);
}
static inline Tensor reshape(const Tensor & self, IntList shape) {
    return detail::infer_type(self).reshape(self, shape);
}
static inline std::tuple<Tensor,Tensor> RoiPooling2d_forward(const Tensor & input, const Tensor & rois, int64_t pooledHeight, int64_t pooledWidth, double spatialScale) {
    return detail::infer_type(input).RoiPooling2d_forward(input, rois, pooledHeight, pooledWidth, spatialScale);
}
static inline Tensor RoiPooling2d_backward(const Tensor & input, const Tensor & rois, int64_t pooledHeight, int64_t pooledWidth, double spatialScale, const Tensor & gradOutput, const Tensor & argmaxes) {
    return detail::infer_type(input).RoiPooling2d_backward(input, rois, pooledHeight, pooledWidth, spatialScale, gradOutput, argmaxes);
}
static inline Tensor round(const Tensor & self) {
    return detail::infer_type(self).round(self);
}
static inline Tensor & round_(Tensor & self) {
    return detail::infer_type(self).round_(self);
}
static inline Tensor & round_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).round_out(result, self);
}
static inline Tensor rrelu(const Tensor & self, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self).rrelu(self, lower, upper, training, generator);
}
static inline Tensor & rrelu_(Tensor & self, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self).rrelu_(self, lower, upper, training, generator);
}
static inline Tensor relu(const Tensor & self) {
    return detail::infer_type(self).relu(self);
}
static inline Tensor & relu_(Tensor & self) {
    return detail::infer_type(self).relu_(self);
}
static inline Tensor prelu(const Tensor & self, const Tensor & weight) {
    return detail::infer_type(self).prelu(self, weight);
}
static inline std::tuple<Tensor,Tensor> prelu_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight) {
    return detail::infer_type(self).prelu_backward(grad_output, self, weight);
}
static inline Tensor hardshrink(const Tensor & self, Scalar lambd) {
    return detail::infer_type(self).hardshrink(self, lambd);
}
static inline Tensor hardshrink_backward(const Tensor & grad_out, const Tensor & self, Scalar lambd) {
    return detail::infer_type(self).hardshrink_backward(grad_out, self, lambd);
}
static inline Tensor rsqrt(const Tensor & self) {
    return detail::infer_type(self).rsqrt(self);
}
static inline Tensor & rsqrt_(Tensor & self) {
    return detail::infer_type(self).rsqrt_(self);
}
static inline Tensor & rsqrt_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).rsqrt_out(result, self);
}
static inline Tensor select(const Tensor & self, int64_t dim, int64_t index) {
    return detail::infer_type(self).select(self, dim, index);
}
static inline Tensor selu(const Tensor & self) {
    return detail::infer_type(self).selu(self);
}
static inline Tensor & selu_(Tensor & self) {
    return detail::infer_type(self).selu_(self);
}
static inline Tensor celu(const Tensor & self, Scalar alpha) {
    return detail::infer_type(self).celu(self, alpha);
}
static inline Tensor & celu_(Tensor & self, Scalar alpha) {
    return detail::infer_type(self).celu_(self, alpha);
}
static inline Tensor sigmoid(const Tensor & self) {
    return detail::infer_type(self).sigmoid(self);
}
static inline Tensor & sigmoid_(Tensor & self) {
    return detail::infer_type(self).sigmoid_(self);
}
static inline Tensor & sigmoid_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).sigmoid_out(result, self);
}
static inline Tensor sin(const Tensor & self) {
    return detail::infer_type(self).sin(self);
}
static inline Tensor & sin_(Tensor & self) {
    return detail::infer_type(self).sin_(self);
}
static inline Tensor & sin_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).sin_out(result, self);
}
static inline Tensor sinh(const Tensor & self) {
    return detail::infer_type(self).sinh(self);
}
static inline Tensor & sinh_(Tensor & self) {
    return detail::infer_type(self).sinh_(self);
}
static inline Tensor & sinh_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).sinh_out(result, self);
}
static inline Tensor detach(const Tensor & self) {
    return detail::infer_type(self).detach(self);
}
static inline Tensor & detach_(Tensor & self) {
    return detail::infer_type(self).detach_(self);
}
static inline int64_t size(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).size(self, dim);
}
static inline Tensor slice(const Tensor & self, int64_t dim, int64_t start, int64_t end, int64_t step) {
    return detail::infer_type(self).slice(self, dim, start, end, step);
}
static inline std::tuple<Tensor,Tensor> slogdet(const Tensor & self) {
    return detail::infer_type(self).slogdet(self);
}
static inline Tensor smm(const Tensor & self, const Tensor & mat2) {
    return detail::infer_type(self).smm(self, mat2);
}
static inline Tensor softmax(const Tensor & self, int64_t dim, ScalarType dtype) {
    return detail::infer_type(self).softmax(self, dim, dtype);
}
static inline Tensor softmax(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).softmax(self, dim);
}
static inline Tensor _softmax(const Tensor & self, int64_t dim, bool half_to_float) {
    return detail::infer_type(self)._softmax(self, dim, half_to_float);
}
static inline Tensor _softmax_backward_data(const Tensor & grad_output, const Tensor & output, int64_t dim, const Tensor & self) {
    return detail::infer_type(self)._softmax_backward_data(grad_output, output, dim, self);
}
static inline Tensor & _sparse_add_out(Tensor & result, const Tensor & self, const Tensor & other, Scalar alpha) {
    return detail::infer_type(self)._sparse_add_out(result, self, other, alpha);
}
static inline Tensor & _sparse_dense_add_out(Tensor & result, const Tensor & self, SparseTensorRef other, Scalar alpha) {
    return detail::infer_type(self)._sparse_dense_add_out(result, self, other, alpha);
}
static inline Tensor & _sparse_div_zerodim_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._sparse_div_zerodim_out(result, self, other);
}
static inline Tensor & _sparse_div_scalar_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._sparse_div_scalar_out(result, self, other);
}
static inline Tensor & _sparse_mul_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._sparse_mul_out(result, self, other);
}
static inline Tensor & _sparse_mul_zerodim_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._sparse_mul_zerodim_out(result, self, other);
}
static inline Tensor & _sparse_mul_scalar_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self)._sparse_mul_scalar_out(result, self, other);
}
static inline std::vector<Tensor> split(const Tensor & self, int64_t split_size, int64_t dim) {
    return detail::infer_type(self).split(self, split_size, dim);
}
static inline std::vector<Tensor> split_with_sizes(const Tensor & self, IntList split_sizes, int64_t dim) {
    return detail::infer_type(self).split_with_sizes(self, split_sizes, dim);
}
static inline Tensor squeeze(const Tensor & self) {
    return detail::infer_type(self).squeeze(self);
}
static inline Tensor squeeze(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).squeeze(self, dim);
}
static inline Tensor sspaddmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).sspaddmm(self, mat1, mat2, beta, alpha);
}
static inline Tensor & sspaddmm_out(Tensor & result, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).sspaddmm_out(result, self, mat1, mat2, beta, alpha);
}
static inline Tensor stack(TensorList tensors, int64_t dim) {
    return detail::infer_type(tensors).stack(tensors, dim);
}
static inline Tensor & stack_out(Tensor & result, TensorList tensors, int64_t dim) {
    return detail::infer_type(result).stack_out(result, tensors, dim);
}
static inline Tensor stft(const Tensor & self, int64_t n_fft, int64_t hop_length, int64_t win_length, const Tensor & window, bool normalized, bool onesided) {
    return detail::infer_type(self).stft(self, n_fft, hop_length, win_length, window, normalized, onesided);
}
static inline int64_t stride(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).stride(self, dim);
}
static inline Tensor sum(const Tensor & self, ScalarType dtype) {
    return detail::infer_type(self).sum(self, dtype);
}
static inline Tensor sum(const Tensor & self) {
    return detail::infer_type(self).sum(self);
}
static inline Tensor sum(const Tensor & self, IntList dim, bool keepdim, ScalarType dtype) {
    return detail::infer_type(self).sum(self, dim, keepdim, dtype);
}
static inline Tensor sum(const Tensor & self, IntList dim, bool keepdim) {
    return detail::infer_type(self).sum(self, dim, keepdim);
}
static inline Tensor sum(const Tensor & self, IntList dim, ScalarType dtype) {
    return detail::infer_type(self).sum(self, dim, dtype);
}
static inline Tensor & sum_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim, ScalarType dtype) {
    return detail::infer_type(self).sum_out(result, self, dim, keepdim, dtype);
}
static inline Tensor & sum_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim) {
    return detail::infer_type(self).sum_out(result, self, dim, keepdim);
}
static inline Tensor & sum_out(Tensor & result, const Tensor & self, IntList dim, ScalarType dtype) {
    return detail::infer_type(self).sum_out(result, self, dim, dtype);
}
static inline Tensor sqrt(const Tensor & self) {
    return detail::infer_type(self).sqrt(self);
}
static inline Tensor & sqrt_(Tensor & self) {
    return detail::infer_type(self).sqrt_(self);
}
static inline Tensor & sqrt_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).sqrt_out(result, self);
}
static inline Tensor std(const Tensor & self, bool unbiased) {
    return detail::infer_type(self).std(self, unbiased);
}
static inline Tensor std(const Tensor & self, int64_t dim, bool unbiased, bool keepdim) {
    return detail::infer_type(self).std(self, dim, unbiased, keepdim);
}
static inline Tensor & std_out(Tensor & result, const Tensor & self, int64_t dim, bool unbiased, bool keepdim) {
    return detail::infer_type(self).std_out(result, self, dim, unbiased, keepdim);
}
static inline Tensor prod(const Tensor & self, ScalarType dtype) {
    return detail::infer_type(self).prod(self, dtype);
}
static inline Tensor prod(const Tensor & self) {
    return detail::infer_type(self).prod(self);
}
static inline Tensor prod(const Tensor & self, int64_t dim, bool keepdim, ScalarType dtype) {
    return detail::infer_type(self).prod(self, dim, keepdim, dtype);
}
static inline Tensor prod(const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).prod(self, dim, keepdim);
}
static inline Tensor prod(const Tensor & self, int64_t dim, ScalarType dtype) {
    return detail::infer_type(self).prod(self, dim, dtype);
}
static inline Tensor & prod_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim, ScalarType dtype) {
    return detail::infer_type(self).prod_out(result, self, dim, keepdim, dtype);
}
static inline Tensor & prod_out(Tensor & result, const Tensor & self, int64_t dim, bool keepdim) {
    return detail::infer_type(self).prod_out(result, self, dim, keepdim);
}
static inline Tensor & prod_out(Tensor & result, const Tensor & self, int64_t dim, ScalarType dtype) {
    return detail::infer_type(self).prod_out(result, self, dim, dtype);
}
static inline Tensor t(const Tensor & self) {
    return detail::infer_type(self).t(self);
}
static inline Tensor tan(const Tensor & self) {
    return detail::infer_type(self).tan(self);
}
static inline Tensor & tan_(Tensor & self) {
    return detail::infer_type(self).tan_(self);
}
static inline Tensor & tan_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).tan_out(result, self);
}
static inline Tensor tanh(const Tensor & self) {
    return detail::infer_type(self).tanh(self);
}
static inline Tensor & tanh_(Tensor & self) {
    return detail::infer_type(self).tanh_(self);
}
static inline Tensor & tanh_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).tanh_out(result, self);
}
static inline Tensor tensordot(const Tensor & self, const Tensor & other, IntList dims_self, IntList dims_other) {
    return detail::infer_type(self).tensordot(self, other, dims_self, dims_other);
}
static inline Tensor threshold(const Tensor & self, Scalar threshold, Scalar value) {
    return detail::infer_type(self).threshold(self, threshold, value);
}
static inline Tensor & threshold_(Tensor & self, Scalar threshold, Scalar value) {
    return detail::infer_type(self).threshold_(self, threshold, value);
}
static inline Tensor & threshold_out(Tensor & result, const Tensor & self, Scalar threshold, Scalar value) {
    return detail::infer_type(self).threshold_out(result, self, threshold, value);
}
static inline Tensor threshold_backward(const Tensor & grad_output, const Tensor & self, Scalar threshold) {
    return detail::infer_type(self).threshold_backward(grad_output, self, threshold);
}
static inline Tensor transpose(const Tensor & self, int64_t dim0, int64_t dim1) {
    return detail::infer_type(self).transpose(self, dim0, dim1);
}
static inline Tensor flip(const Tensor & self, IntList dims) {
    return detail::infer_type(self).flip(self, dims);
}
static inline Tensor roll(const Tensor & self, IntList shifts, IntList dims) {
    return detail::infer_type(self).roll(self, shifts, dims);
}
static inline Tensor rot90(const Tensor & self, int64_t k, IntList dims) {
    return detail::infer_type(self).rot90(self, k, dims);
}
static inline Tensor _trilinear(const Tensor & i1, const Tensor & i2, const Tensor & i3, IntList expand1, IntList expand2, IntList expand3, IntList sumdim, int64_t unroll_dim) {
    return detail::infer_type(i1)._trilinear(i1, i2, i3, expand1, expand2, expand3, sumdim, unroll_dim);
}
static inline Tensor triplet_margin_loss(const Tensor & anchor, const Tensor & positive, const Tensor & negative, double margin, double p, double eps, bool swap, int64_t reduction) {
    return detail::infer_type(anchor).triplet_margin_loss(anchor, positive, negative, margin, p, eps, swap, reduction);
}
static inline Tensor trunc(const Tensor & self) {
    return detail::infer_type(self).trunc(self);
}
static inline Tensor & trunc_(Tensor & self) {
    return detail::infer_type(self).trunc_(self);
}
static inline Tensor & trunc_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).trunc_out(result, self);
}
static inline std::tuple<Tensor,Tensor> _unique(const Tensor & self, bool sorted, bool return_inverse) {
    return detail::infer_type(self)._unique(self, sorted, return_inverse);
}
static inline std::tuple<Tensor,Tensor> _unique_dim(const Tensor & self, int64_t dim, bool sorted, bool return_inverse) {
    return detail::infer_type(self)._unique_dim(self, dim, sorted, return_inverse);
}
static inline Tensor _unsafe_view(const Tensor & self, IntList size) {
    return detail::infer_type(self)._unsafe_view(self, size);
}
static inline Tensor unsqueeze(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).unsqueeze(self, dim);
}
static inline Tensor var(const Tensor & self, bool unbiased) {
    return detail::infer_type(self).var(self, unbiased);
}
static inline Tensor var(const Tensor & self, int64_t dim, bool unbiased, bool keepdim) {
    return detail::infer_type(self).var(self, dim, unbiased, keepdim);
}
static inline Tensor & var_out(Tensor & result, const Tensor & self, int64_t dim, bool unbiased, bool keepdim) {
    return detail::infer_type(self).var_out(result, self, dim, unbiased, keepdim);
}
static inline Tensor where(const Tensor & condition, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).where(condition, self, other);
}
static inline Tensor _s_where(const Tensor & condition, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self)._s_where(condition, self, other);
}
static inline Tensor norm_except_dim(const Tensor & v, int64_t pow, int64_t dim) {
    return detail::infer_type(v).norm_except_dim(v, pow, dim);
}
static inline Tensor _weight_norm(const Tensor & v, const Tensor & g, int64_t dim) {
    return detail::infer_type(v)._weight_norm(v, g, dim);
}
static inline std::tuple<Tensor,Tensor> _weight_norm_cuda_interface(const Tensor & v, const Tensor & g, int64_t dim) {
    return detail::infer_type(v)._weight_norm_cuda_interface(v, g, dim);
}
static inline std::tuple<Tensor,Tensor> _weight_norm_cuda_interface_backward(const Tensor & grad_w, const Tensor & saved_v, const Tensor & saved_g, const Tensor & saved_norms, int64_t dim) {
    return detail::infer_type(grad_w)._weight_norm_cuda_interface_backward(grad_w, saved_v, saved_g, saved_norms, dim);
}
static inline std::tuple<Tensor,Tensor> _weight_norm_differentiable_backward(const Tensor & grad_w, const Tensor & saved_v, const Tensor & saved_g, const Tensor & saved_norms, int64_t dim) {
    return detail::infer_type(grad_w)._weight_norm_differentiable_backward(grad_w, saved_v, saved_g, saved_norms, dim);
}
static inline Tensor zeros(IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::zeros(size, options);
}
static inline Tensor & zeros_out(Tensor & result, IntList size) {
    return detail::infer_type(result).zeros_out(result, size);
}
static inline Tensor zeros_like(const Tensor & self) {
    return detail::infer_type(self).zeros_like(self);
}
static inline Tensor zeros_like(const Tensor & self, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::zeros_like(self, options);
}
static inline Tensor _standard_gamma_grad(const Tensor & self, const Tensor & output) {
    return detail::infer_type(self)._standard_gamma_grad(self, output);
}
static inline Tensor _standard_gamma(const Tensor & self, Generator * generator) {
    return detail::infer_type(self)._standard_gamma(self, generator);
}
static inline Tensor poisson(const Tensor & self, Generator * generator) {
    return detail::infer_type(self).poisson(self, generator);
}
static inline Tensor native_norm(const Tensor & self, Scalar p) {
    return detail::infer_type(self).native_norm(self, p);
}
static inline Tensor _sparse_sum(const Tensor & self) {
    return detail::infer_type(self)._sparse_sum(self);
}
static inline Tensor _sparse_sum(const Tensor & self, ScalarType dtype) {
    return detail::infer_type(self)._sparse_sum(self, dtype);
}
static inline Tensor _sparse_sum(const Tensor & self, IntList dim) {
    return detail::infer_type(self)._sparse_sum(self, dim);
}
static inline Tensor _sparse_sum(const Tensor & self, IntList dim, ScalarType dtype) {
    return detail::infer_type(self)._sparse_sum(self, dim, dtype);
}
static inline Tensor _sparse_sum_backward(const Tensor & grad, const Tensor & self, IntList dim) {
    return detail::infer_type(self)._sparse_sum_backward(grad, self, dim);
}
static inline Tensor norm(const Tensor & self, Scalar p) {
    return detail::infer_type(self).norm(self, p);
}
static inline Tensor norm(const Tensor & self, Scalar p, int64_t dim, bool keepdim) {
    return detail::infer_type(self).norm(self, p, dim, keepdim);
}
static inline Tensor & norm_out(Tensor & result, const Tensor & self, Scalar p, int64_t dim, bool keepdim) {
    return detail::infer_type(self).norm_out(result, self, p, dim, keepdim);
}
static inline Tensor frobenius_norm(const Tensor & self) {
    return detail::infer_type(self).frobenius_norm(self);
}
static inline Tensor frobenius_norm(const Tensor & self, IntList dim, bool keepdim) {
    return detail::infer_type(self).frobenius_norm(self, dim, keepdim);
}
static inline Tensor & frobenius_norm_out(Tensor & result, const Tensor & self, IntList dim, bool keepdim) {
    return detail::infer_type(self).frobenius_norm_out(result, self, dim, keepdim);
}
static inline Tensor nuclear_norm(const Tensor & self, bool keepdim) {
    return detail::infer_type(self).nuclear_norm(self, keepdim);
}
static inline Tensor & nuclear_norm_out(Tensor & result, const Tensor & self, bool keepdim) {
    return detail::infer_type(self).nuclear_norm_out(result, self, keepdim);
}
static inline Tensor native_clone(const Tensor & self) {
    return detail::infer_type(self).native_clone(self);
}
static inline Tensor clone(const Tensor & self) {
    return detail::infer_type(self).clone(self);
}
static inline Tensor & native_resize_as_(Tensor & self, const Tensor & the_template) {
    return detail::infer_type(self).native_resize_as_(self, the_template);
}
static inline Tensor & resize_as_(Tensor & self, const Tensor & the_template) {
    return detail::infer_type(self).resize_as_(self, the_template);
}
static inline Tensor & native_pow_out(Tensor & result, const Tensor & self, Scalar exponent) {
    return detail::infer_type(self).native_pow_out(result, self, exponent);
}
static inline Tensor native_pow(const Tensor & self, Scalar exponent) {
    return detail::infer_type(self).native_pow(self, exponent);
}
static inline Tensor & pow_out(Tensor & result, const Tensor & self, Scalar exponent) {
    return detail::infer_type(self).pow_out(result, self, exponent);
}
static inline Tensor pow(const Tensor & self, Scalar exponent) {
    return detail::infer_type(self).pow(self, exponent);
}
static inline Tensor & native_zero_(Tensor & self) {
    return detail::infer_type(self).native_zero_(self);
}
static inline Tensor & zero_(Tensor & self) {
    return detail::infer_type(self).zero_(self);
}
static inline Tensor & sub_out(Tensor & result, const Tensor & self, const Tensor & other, Scalar alpha) {
    return detail::infer_type(self).sub_out(result, self, other, alpha);
}
static inline Tensor sub(const Tensor & self, const Tensor & other, Scalar alpha) {
    return detail::infer_type(self).sub(self, other, alpha);
}
static inline Tensor sub(const Tensor & self, Scalar other, Scalar alpha) {
    return detail::infer_type(self).sub(self, other, alpha);
}
static inline Tensor rsub(const Tensor & self, const Tensor & other, Scalar alpha) {
    return detail::infer_type(self).rsub(self, other, alpha);
}
static inline Tensor rsub(const Tensor & self, Scalar other, Scalar alpha) {
    return detail::infer_type(self).rsub(self, other, alpha);
}
static inline Tensor & s_native_addmm_out(Tensor & result, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).s_native_addmm_out(result, self, mat1, mat2, beta, alpha);
}
static inline Tensor s_native_addmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).s_native_addmm(self, mat1, mat2, beta, alpha);
}
static inline Tensor & s_native_addmm_(Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).s_native_addmm_(self, mat1, mat2, beta, alpha);
}
static inline Tensor _sparse_addmm(const Tensor & self, const Tensor & sparse, const Tensor & dense, Scalar beta, Scalar alpha) {
    return detail::infer_type(self)._sparse_addmm(self, sparse, dense, beta, alpha);
}
static inline Tensor & addmm_out(Tensor & result, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addmm_out(result, self, mat1, mat2, beta, alpha);
}
static inline Tensor addmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addmm(self, mat1, mat2, beta, alpha);
}
static inline Tensor sparse_coo_tensor(IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::sparse_coo_tensor(size, options);
}
static inline Tensor sparse_coo_tensor(const Tensor & indices, const Tensor & values, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::sparse_coo_tensor(indices, values, options);
}
static inline Tensor sparse_coo_tensor(const Tensor & indices, const Tensor & values, IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::sparse_coo_tensor(indices, values, size, options);
}
static inline Tensor _sparse_coo_tensor_unsafe(const Tensor & indices, const Tensor & values, IntList size, const TensorOptions & options) {
    const DeviceGuard guard(options.device());
    return at::native::_sparse_coo_tensor_unsafe(indices, values, size, options);
}
static inline Tensor _sparse_coo_tensor_with_dims(int64_t sparse_dim, int64_t dense_dim, IntList size, const TensorOptions & options) {
    return at::getType(options)._sparse_coo_tensor_with_dims(sparse_dim, dense_dim, size, options);
}
static inline Tensor _sparse_coo_tensor_with_dims_and_tensors(int64_t sparse_dim, int64_t dense_dim, IntList size, const Tensor & indices, const Tensor & values, const TensorOptions & options) {
    return at::getType(options)._sparse_coo_tensor_with_dims_and_tensors(sparse_dim, dense_dim, size, indices, values, options);
}
static inline Tensor & hspmm_out(Tensor & result, const Tensor & mat1, const Tensor & mat2) {
    return detail::infer_type(result).hspmm_out(result, mat1, mat2);
}
static inline Tensor hspmm(const Tensor & mat1, const Tensor & mat2) {
    return detail::infer_type(mat1).hspmm(mat1, mat2);
}
static inline Tensor & copy_sparse_to_sparse_(Tensor & self, const Tensor & src, bool non_blocking) {
    return detail::infer_type(self).copy_sparse_to_sparse_(self, src, non_blocking);
}
static inline int64_t numel(const Tensor & self) {
    return detail::infer_type(self).numel(self);
}
static inline std::vector<Tensor> unbind(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).unbind(self, dim);
}
static inline std::vector<Tensor> meshgrid(TensorList tensors) {
    return detail::infer_type(tensors).meshgrid(tensors);
}
static inline Scalar _local_scalar_dense(const Tensor & self) {
    return detail::infer_type(self)._local_scalar_dense(self);
}
static inline std::tuple<Tensor,Tensor,Tensor> _thnn_fused_lstm_cell(const Tensor & input_gates, const Tensor & hidden_gates, const Tensor & cx, const Tensor & input_bias, const Tensor & hidden_bias) {
    return detail::infer_type(input_gates)._thnn_fused_lstm_cell(input_gates, hidden_gates, cx, input_bias, hidden_bias);
}
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_fused_lstm_cell_backward(const Tensor & grad_hy, const Tensor & grad_cy, const Tensor & cx, const Tensor & cy, const Tensor & workspace, bool has_bias) {
    return detail::infer_type(cx)._thnn_fused_lstm_cell_backward(grad_hy, grad_cy, cx, cy, workspace, has_bias);
}
static inline std::tuple<Tensor,Tensor> _thnn_fused_gru_cell(const Tensor & input_gates, const Tensor & hidden_gates, const Tensor & hx, const Tensor & input_bias, const Tensor & hidden_bias) {
    return detail::infer_type(input_gates)._thnn_fused_gru_cell(input_gates, hidden_gates, hx, input_bias, hidden_bias);
}
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_fused_gru_cell_backward(const Tensor & grad_hy, const Tensor & workspace, bool has_bias) {
    return detail::infer_type(grad_hy)._thnn_fused_gru_cell_backward(grad_hy, workspace, has_bias);
}
static inline std::tuple<Tensor,Tensor,Tensor> lstm(const Tensor & input, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
    return detail::infer_type(input).lstm(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
}
static inline std::tuple<Tensor,Tensor,Tensor> lstm(const Tensor & data, const Tensor & batch_sizes, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
    return detail::infer_type(data).lstm(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
}
static inline std::tuple<Tensor,Tensor> gru(const Tensor & input, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
    return detail::infer_type(input).gru(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
}
static inline std::tuple<Tensor,Tensor> gru(const Tensor & data, const Tensor & batch_sizes, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
    return detail::infer_type(data).gru(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
}
static inline std::tuple<Tensor,Tensor> rnn_tanh(const Tensor & input, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
    return detail::infer_type(input).rnn_tanh(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
}
static inline std::tuple<Tensor,Tensor> rnn_tanh(const Tensor & data, const Tensor & batch_sizes, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
    return detail::infer_type(data).rnn_tanh(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
}
static inline std::tuple<Tensor,Tensor> rnn_relu(const Tensor & input, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
    return detail::infer_type(input).rnn_relu(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
}
static inline std::tuple<Tensor,Tensor> rnn_relu(const Tensor & data, const Tensor & batch_sizes, const Tensor & hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
    return detail::infer_type(data).rnn_relu(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
}
static inline std::tuple<Tensor,Tensor> lstm_cell(const Tensor & input, TensorList hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih, const Tensor & b_hh) {
    return detail::infer_type(input).lstm_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
}
static inline Tensor gru_cell(const Tensor & input, const Tensor & hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih, const Tensor & b_hh) {
    return detail::infer_type(input).gru_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
}
static inline Tensor rnn_tanh_cell(const Tensor & input, const Tensor & hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih, const Tensor & b_hh) {
    return detail::infer_type(input).rnn_tanh_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
}
static inline Tensor rnn_relu_cell(const Tensor & input, const Tensor & hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih, const Tensor & b_hh) {
    return detail::infer_type(input).rnn_relu_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
}
static inline std::tuple<Tensor,Tensor> _pack_padded_sequence(const Tensor & input, const Tensor & lengths, bool batch_first) {
    return detail::infer_type(input)._pack_padded_sequence(input, lengths, batch_first);
}
static inline Tensor _pack_padded_sequence_backward(const Tensor & grad, IntList input_size, const Tensor & batch_sizes, bool batch_first) {
    return detail::infer_type(grad)._pack_padded_sequence_backward(grad, input_size, batch_sizes, batch_first);
}
static inline std::tuple<Tensor,Tensor> _pad_packed_sequence(const Tensor & data, const Tensor & batch_sizes, bool batch_first, Scalar padding_value, int64_t total_length) {
    return detail::infer_type(data)._pad_packed_sequence(data, batch_sizes, batch_first, padding_value, total_length);
}
static inline Tensor __and__(const Tensor & self, Scalar other) {
    return detail::infer_type(self).__and__(self, other);
}
static inline Tensor __and__(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).__and__(self, other);
}
static inline Tensor __or__(const Tensor & self, Scalar other) {
    return detail::infer_type(self).__or__(self, other);
}
static inline Tensor __or__(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).__or__(self, other);
}
static inline Tensor __xor__(const Tensor & self, Scalar other) {
    return detail::infer_type(self).__xor__(self, other);
}
static inline Tensor __xor__(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).__xor__(self, other);
}
static inline Tensor __lshift__(const Tensor & self, Scalar other) {
    return detail::infer_type(self).__lshift__(self, other);
}
static inline Tensor __lshift__(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).__lshift__(self, other);
}
static inline Tensor __rshift__(const Tensor & self, Scalar other) {
    return detail::infer_type(self).__rshift__(self, other);
}
static inline Tensor __rshift__(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).__rshift__(self, other);
}
static inline Tensor & addbmm_out(Tensor & result, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addbmm_out(result, self, batch1, batch2, beta, alpha);
}
static inline Tensor addbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
    return detail::infer_type(self).addbmm(self, batch1, batch2, beta, alpha);
}
static inline Tensor & diag_out(Tensor & result, const Tensor & self, int64_t diagonal) {
    return detail::infer_type(self).diag_out(result, self, diagonal);
}
static inline Tensor diag(const Tensor & self, int64_t diagonal) {
    return detail::infer_type(self).diag(self, diagonal);
}
static inline Tensor & cross_out(Tensor & result, const Tensor & self, const Tensor & other, int64_t dim) {
    return detail::infer_type(self).cross_out(result, self, other, dim);
}
static inline Tensor cross(const Tensor & self, const Tensor & other, int64_t dim) {
    return detail::infer_type(self).cross(self, other, dim);
}
static inline Tensor & triu_out(Tensor & result, const Tensor & self, int64_t diagonal) {
    return detail::infer_type(self).triu_out(result, self, diagonal);
}
static inline Tensor triu(const Tensor & self, int64_t diagonal) {
    return detail::infer_type(self).triu(self, diagonal);
}
static inline Tensor & tril_out(Tensor & result, const Tensor & self, int64_t diagonal) {
    return detail::infer_type(self).tril_out(result, self, diagonal);
}
static inline Tensor tril(const Tensor & self, int64_t diagonal) {
    return detail::infer_type(self).tril(self, diagonal);
}
static inline Tensor trace(const Tensor & self) {
    return detail::infer_type(self).trace(self);
}
static inline Tensor & ne_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self).ne_out(result, self, other);
}
static inline Tensor ne(const Tensor & self, Scalar other) {
    return detail::infer_type(self).ne(self, other);
}
static inline Tensor & ne_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).ne_out(result, self, other);
}
static inline Tensor ne(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).ne(self, other);
}
static inline Tensor & eq_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self).eq_out(result, self, other);
}
static inline Tensor eq(const Tensor & self, Scalar other) {
    return detail::infer_type(self).eq(self, other);
}
static inline Tensor & eq_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).eq_out(result, self, other);
}
static inline Tensor eq(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).eq(self, other);
}
static inline Tensor & ge_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self).ge_out(result, self, other);
}
static inline Tensor ge(const Tensor & self, Scalar other) {
    return detail::infer_type(self).ge(self, other);
}
static inline Tensor & ge_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).ge_out(result, self, other);
}
static inline Tensor ge(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).ge(self, other);
}
static inline Tensor & le_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self).le_out(result, self, other);
}
static inline Tensor le(const Tensor & self, Scalar other) {
    return detail::infer_type(self).le(self, other);
}
static inline Tensor & le_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).le_out(result, self, other);
}
static inline Tensor le(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).le(self, other);
}
static inline Tensor & gt_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self).gt_out(result, self, other);
}
static inline Tensor gt(const Tensor & self, Scalar other) {
    return detail::infer_type(self).gt(self, other);
}
static inline Tensor & gt_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).gt_out(result, self, other);
}
static inline Tensor gt(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).gt(self, other);
}
static inline Tensor & lt_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self).lt_out(result, self, other);
}
static inline Tensor lt(const Tensor & self, Scalar other) {
    return detail::infer_type(self).lt(self, other);
}
static inline Tensor & lt_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).lt_out(result, self, other);
}
static inline Tensor lt(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).lt(self, other);
}
static inline Tensor & take_out(Tensor & result, const Tensor & self, const Tensor & index) {
    return detail::infer_type(self).take_out(result, self, index);
}
static inline Tensor take(const Tensor & self, const Tensor & index) {
    return detail::infer_type(self).take(self, index);
}
static inline Tensor & index_select_out(Tensor & result, const Tensor & self, int64_t dim, const Tensor & index) {
    return detail::infer_type(self).index_select_out(result, self, dim, index);
}
static inline Tensor index_select(const Tensor & self, int64_t dim, const Tensor & index) {
    return detail::infer_type(self).index_select(self, dim, index);
}
static inline Tensor & masked_select_out(Tensor & result, const Tensor & self, const Tensor & mask) {
    return detail::infer_type(self).masked_select_out(result, self, mask);
}
static inline Tensor masked_select(const Tensor & self, const Tensor & mask) {
    return detail::infer_type(self).masked_select(self, mask);
}
static inline Tensor & nonzero_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).nonzero_out(result, self);
}
static inline Tensor nonzero(const Tensor & self) {
    return detail::infer_type(self).nonzero(self);
}
static inline Tensor & gather_out(Tensor & result, const Tensor & self, int64_t dim, const Tensor & index) {
    return detail::infer_type(self).gather_out(result, self, dim, index);
}
static inline Tensor gather(const Tensor & self, int64_t dim, const Tensor & index) {
    return detail::infer_type(self).gather(self, dim, index);
}
static inline Tensor & addcmul_out(Tensor & result, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self).addcmul_out(result, self, tensor1, tensor2, value);
}
static inline Tensor addcmul(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self).addcmul(self, tensor1, tensor2, value);
}
static inline Tensor & addcdiv_out(Tensor & result, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self).addcdiv_out(result, self, tensor1, tensor2, value);
}
static inline Tensor addcdiv(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
    return detail::infer_type(self).addcdiv(self, tensor1, tensor2, value);
}
static inline std::tuple<Tensor &,Tensor &> gels_out(Tensor & X, Tensor & qr, const Tensor & self, const Tensor & A) {
    return detail::infer_type(self).gels_out(X, qr, self, A);
}
static inline std::tuple<Tensor,Tensor> gels(const Tensor & self, const Tensor & A) {
    return detail::infer_type(self).gels(self, A);
}
static inline std::tuple<Tensor &,Tensor &> trtrs_out(Tensor & X, Tensor & M, const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular) {
    return detail::infer_type(self).trtrs_out(X, M, self, A, upper, transpose, unitriangular);
}
static inline std::tuple<Tensor,Tensor> trtrs(const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular) {
    return detail::infer_type(self).trtrs(self, A, upper, transpose, unitriangular);
}
static inline std::tuple<Tensor &,Tensor &> symeig_out(Tensor & e, Tensor & V, const Tensor & self, bool eigenvectors, bool upper) {
    return detail::infer_type(self).symeig_out(e, V, self, eigenvectors, upper);
}
static inline std::tuple<Tensor,Tensor> symeig(const Tensor & self, bool eigenvectors, bool upper) {
    return detail::infer_type(self).symeig(self, eigenvectors, upper);
}
static inline std::tuple<Tensor &,Tensor &> eig_out(Tensor & e, Tensor & v, const Tensor & self, bool eigenvectors) {
    return detail::infer_type(self).eig_out(e, v, self, eigenvectors);
}
static inline std::tuple<Tensor,Tensor> eig(const Tensor & self, bool eigenvectors) {
    return detail::infer_type(self).eig(self, eigenvectors);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> svd_out(Tensor & U, Tensor & S, Tensor & V, const Tensor & self, bool some, bool compute_uv) {
    return detail::infer_type(self).svd_out(U, S, V, self, some, compute_uv);
}
static inline std::tuple<Tensor,Tensor,Tensor> svd(const Tensor & self, bool some, bool compute_uv) {
    return detail::infer_type(self).svd(self, some, compute_uv);
}
static inline Tensor & cholesky_out(Tensor & result, const Tensor & self, bool upper) {
    return detail::infer_type(self).cholesky_out(result, self, upper);
}
static inline Tensor cholesky(const Tensor & self, bool upper) {
    return detail::infer_type(self).cholesky(self, upper);
}
static inline Tensor _cholesky_helper(const Tensor & self, bool upper) {
    return detail::infer_type(self)._cholesky_helper(self, upper);
}
static inline Tensor & potrs_out(Tensor & result, const Tensor & self, const Tensor & input2, bool upper) {
    return detail::infer_type(self).potrs_out(result, self, input2, upper);
}
static inline Tensor potrs(const Tensor & self, const Tensor & input2, bool upper) {
    return detail::infer_type(self).potrs(self, input2, upper);
}
static inline Tensor _potrs_helper(const Tensor & self, const Tensor & A, bool upper) {
    return detail::infer_type(self)._potrs_helper(self, A, upper);
}
static inline Tensor & potri_out(Tensor & result, const Tensor & self, bool upper) {
    return detail::infer_type(self).potri_out(result, self, upper);
}
static inline Tensor potri(const Tensor & self, bool upper) {
    return detail::infer_type(self).potri(self, upper);
}
static inline std::tuple<Tensor &,Tensor &> pstrf_out(Tensor & u, Tensor & piv, const Tensor & self, bool upper, Scalar tol) {
    return detail::infer_type(self).pstrf_out(u, piv, self, upper, tol);
}
static inline std::tuple<Tensor,Tensor> pstrf(const Tensor & self, bool upper, Scalar tol) {
    return detail::infer_type(self).pstrf(self, upper, tol);
}
static inline std::tuple<Tensor &,Tensor &> qr_out(Tensor & Q, Tensor & R, const Tensor & self) {
    return detail::infer_type(self).qr_out(Q, R, self);
}
static inline std::tuple<Tensor,Tensor> qr(const Tensor & self) {
    return detail::infer_type(self).qr(self);
}
static inline std::tuple<Tensor &,Tensor &> geqrf_out(Tensor & result0, Tensor & result1, const Tensor & self) {
    return detail::infer_type(self).geqrf_out(result0, result1, self);
}
static inline std::tuple<Tensor,Tensor> geqrf(const Tensor & self) {
    return detail::infer_type(self).geqrf(self);
}
static inline Tensor & orgqr_out(Tensor & result, const Tensor & self, const Tensor & input2) {
    return detail::infer_type(self).orgqr_out(result, self, input2);
}
static inline Tensor orgqr(const Tensor & self, const Tensor & input2) {
    return detail::infer_type(self).orgqr(self, input2);
}
static inline Tensor & ormqr_out(Tensor & result, const Tensor & self, const Tensor & input2, const Tensor & input3, bool left, bool transpose) {
    return detail::infer_type(self).ormqr_out(result, self, input2, input3, left, transpose);
}
static inline Tensor ormqr(const Tensor & self, const Tensor & input2, const Tensor & input3, bool left, bool transpose) {
    return detail::infer_type(self).ormqr(self, input2, input3, left, transpose);
}
static inline std::tuple<Tensor &,Tensor &> btrifact_out(Tensor & A_LU, Tensor & pivots, const Tensor & self, bool pivot) {
    return detail::infer_type(self).btrifact_out(A_LU, pivots, self, pivot);
}
static inline std::tuple<Tensor,Tensor> btrifact(const Tensor & self, bool pivot) {
    return detail::infer_type(self).btrifact(self, pivot);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> btrifact_with_info_out(Tensor & A_LU, Tensor & pivots, Tensor & info, const Tensor & self, bool pivot) {
    return detail::infer_type(self).btrifact_with_info_out(A_LU, pivots, info, self, pivot);
}
static inline std::tuple<Tensor,Tensor,Tensor> btrifact_with_info(const Tensor & self, bool pivot) {
    return detail::infer_type(self).btrifact_with_info(self, pivot);
}
static inline Tensor & btrisolve_out(Tensor & result, const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots) {
    return detail::infer_type(self).btrisolve_out(result, self, LU_data, LU_pivots);
}
static inline Tensor btrisolve(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots) {
    return detail::infer_type(self).btrisolve(self, LU_data, LU_pivots);
}
static inline Tensor & multinomial_out(Tensor & result, const Tensor & self, int64_t num_samples, bool replacement, Generator * generator) {
    return detail::infer_type(self).multinomial_out(result, self, num_samples, replacement, generator);
}
static inline Tensor multinomial(const Tensor & self, int64_t num_samples, bool replacement, Generator * generator) {
    return detail::infer_type(self).multinomial(self, num_samples, replacement, generator);
}
static inline Tensor & lgamma_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).lgamma_out(result, self);
}
static inline Tensor lgamma(const Tensor & self) {
    return detail::infer_type(self).lgamma(self);
}
static inline Tensor & digamma_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).digamma_out(result, self);
}
static inline Tensor digamma(const Tensor & self) {
    return detail::infer_type(self).digamma(self);
}
static inline Tensor & polygamma_out(Tensor & result, int64_t n, const Tensor & self) {
    return detail::infer_type(self).polygamma_out(result, n, self);
}
static inline Tensor polygamma(int64_t n, const Tensor & self) {
    return detail::infer_type(self).polygamma(n, self);
}
static inline Tensor & erfinv_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).erfinv_out(result, self);
}
static inline Tensor erfinv(const Tensor & self) {
    return detail::infer_type(self).erfinv(self);
}
static inline Tensor & frac_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).frac_out(result, self);
}
static inline Tensor frac(const Tensor & self) {
    return detail::infer_type(self).frac(self);
}
static inline Tensor dist(const Tensor & self, const Tensor & other, Scalar p) {
    return detail::infer_type(self).dist(self, other, p);
}
static inline Tensor & reciprocal_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).reciprocal_out(result, self);
}
static inline Tensor reciprocal(const Tensor & self) {
    return detail::infer_type(self).reciprocal(self);
}
static inline Tensor & neg_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).neg_out(result, self);
}
static inline Tensor neg(const Tensor & self) {
    return detail::infer_type(self).neg(self);
}
static inline Tensor & atan2_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).atan2_out(result, self, other);
}
static inline Tensor atan2(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).atan2(self, other);
}
static inline Tensor & lerp_out(Tensor & result, const Tensor & self, const Tensor & end, Scalar weight) {
    return detail::infer_type(self).lerp_out(result, self, end, weight);
}
static inline Tensor lerp(const Tensor & self, const Tensor & end, Scalar weight) {
    return detail::infer_type(self).lerp(self, end, weight);
}
static inline Tensor & histc_out(Tensor & result, const Tensor & self, int64_t bins, Scalar min, Scalar max) {
    return detail::infer_type(self).histc_out(result, self, bins, min, max);
}
static inline Tensor histc(const Tensor & self, int64_t bins, Scalar min, Scalar max) {
    return detail::infer_type(self).histc(self, bins, min, max);
}
static inline Tensor & sign_out(Tensor & result, const Tensor & self) {
    return detail::infer_type(self).sign_out(result, self);
}
static inline Tensor sign(const Tensor & self) {
    return detail::infer_type(self).sign(self);
}
static inline Tensor & fmod_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self).fmod_out(result, self, other);
}
static inline Tensor fmod(const Tensor & self, Scalar other) {
    return detail::infer_type(self).fmod(self, other);
}
static inline Tensor & fmod_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).fmod_out(result, self, other);
}
static inline Tensor fmod(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).fmod(self, other);
}
static inline Tensor & remainder_out(Tensor & result, const Tensor & self, Scalar other) {
    return detail::infer_type(self).remainder_out(result, self, other);
}
static inline Tensor remainder(const Tensor & self, Scalar other) {
    return detail::infer_type(self).remainder(self, other);
}
static inline Tensor & remainder_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).remainder_out(result, self, other);
}
static inline Tensor remainder(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).remainder(self, other);
}
static inline Tensor & min_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).min_out(result, self, other);
}
static inline Tensor min(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).min(self, other);
}
static inline Tensor min(const Tensor & self) {
    return detail::infer_type(self).min(self);
}
static inline Tensor & max_out(Tensor & result, const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).max_out(result, self, other);
}
static inline Tensor max(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).max(self, other);
}
static inline Tensor max(const Tensor & self) {
    return detail::infer_type(self).max(self);
}
static inline Tensor median(const Tensor & self) {
    return detail::infer_type(self).median(self);
}
static inline std::tuple<Tensor &,Tensor &> sort_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool descending) {
    return detail::infer_type(self).sort_out(values, indices, self, dim, descending);
}
static inline std::tuple<Tensor,Tensor> sort(const Tensor & self, int64_t dim, bool descending) {
    return detail::infer_type(self).sort(self, dim, descending);
}
static inline std::tuple<Tensor &,Tensor &> topk_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted) {
    return detail::infer_type(self).topk_out(values, indices, self, k, dim, largest, sorted);
}
static inline std::tuple<Tensor,Tensor> topk(const Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted) {
    return detail::infer_type(self).topk(self, k, dim, largest, sorted);
}
static inline Tensor all(const Tensor & self) {
    return detail::infer_type(self).all(self);
}
static inline Tensor any(const Tensor & self) {
    return detail::infer_type(self).any(self);
}
static inline Tensor & renorm_out(Tensor & result, const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm) {
    return detail::infer_type(self).renorm_out(result, self, p, dim, maxnorm);
}
static inline Tensor renorm(const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm) {
    return detail::infer_type(self).renorm(self, p, dim, maxnorm);
}
static inline bool equal(const Tensor & self, const Tensor & other) {
    return detail::infer_type(self).equal(self, other);
}
static inline Tensor & pow_out(Tensor & result, const Tensor & self, const Tensor & exponent) {
    return detail::infer_type(self).pow_out(result, self, exponent);
}
static inline Tensor pow(const Tensor & self, const Tensor & exponent) {
    return detail::infer_type(self).pow(self, exponent);
}
static inline Tensor & pow_out(Tensor & result, Scalar self, const Tensor & exponent) {
    return detail::infer_type(result).pow_out(result, self, exponent);
}
static inline Tensor pow(Scalar self, const Tensor & exponent) {
    return detail::infer_type(exponent).pow(self, exponent);
}
static inline Tensor & normal_out(Tensor & output, const Tensor & mean, double std, Generator * generator) {
    return detail::infer_type(output).normal_out(output, mean, std, generator);
}
static inline Tensor normal(const Tensor & mean, double std, Generator * generator) {
    return detail::infer_type(mean).normal(mean, std, generator);
}
static inline Tensor & normal_out(Tensor & output, double mean, const Tensor & std, Generator * generator) {
    return detail::infer_type(output).normal_out(output, mean, std, generator);
}
static inline Tensor normal(double mean, const Tensor & std, Generator * generator) {
    return detail::infer_type(std).normal(mean, std, generator);
}
static inline Tensor & normal_out(Tensor & output, const Tensor & mean, const Tensor & std, Generator * generator) {
    return detail::infer_type(output).normal_out(output, mean, std, generator);
}
static inline Tensor normal(const Tensor & mean, const Tensor & std, Generator * generator) {
    return detail::infer_type(mean).normal(mean, std, generator);
}
static inline Tensor alias(const Tensor & self) {
    return detail::infer_type(self).alias(self);
}
static inline Tensor & _dirichlet_grad_out(Tensor & output, const Tensor & x, const Tensor & alpha, const Tensor & total) {
    return detail::infer_type(output)._dirichlet_grad_out(output, x, alpha, total);
}
static inline Tensor _dirichlet_grad(const Tensor & x, const Tensor & alpha, const Tensor & total) {
    return detail::infer_type(x)._dirichlet_grad(x, alpha, total);
}
static inline Tensor & binary_cross_entropy_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self).binary_cross_entropy_out(output, self, target, weight, reduction);
}
static inline Tensor binary_cross_entropy(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self).binary_cross_entropy(self, target, weight, reduction);
}
static inline Tensor & binary_cross_entropy_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self).binary_cross_entropy_backward_out(grad_input, grad_output, self, target, weight, reduction);
}
static inline Tensor binary_cross_entropy_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self).binary_cross_entropy_backward(grad_output, self, target, weight, reduction);
}
static inline Tensor & mse_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).mse_loss_out(output, self, target, reduction);
}
static inline Tensor mse_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).mse_loss(self, target, reduction);
}
static inline Tensor & mse_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).mse_loss_backward_out(grad_input, grad_output, self, target, reduction);
}
static inline Tensor mse_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).mse_loss_backward(grad_output, self, target, reduction);
}
static inline Tensor & l1_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).l1_loss_out(output, self, target, reduction);
}
static inline Tensor l1_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).l1_loss(self, target, reduction);
}
static inline Tensor & l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).l1_loss_backward_out(grad_input, grad_output, self, target, reduction);
}
static inline Tensor l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).l1_loss_backward(grad_output, self, target, reduction);
}
static inline Tensor & multi_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self).multi_margin_loss_out(output, self, target, p, margin, weight, reduction);
}
static inline Tensor multi_margin_loss(const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self).multi_margin_loss(self, target, p, margin, weight, reduction);
}
static inline Tensor & multi_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
    return detail::infer_type(self).multi_margin_loss_backward_out(grad_input, grad_output, self, target, p, margin, weight, reduction);
}
static inline 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) {
    return detail::infer_type(self).multi_margin_loss_backward(grad_output, self, target, p, margin, weight, reduction);
}
static inline Tensor & multilabel_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).multilabel_margin_loss_out(output, self, target, reduction);
}
static inline Tensor multilabel_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).multilabel_margin_loss(self, target, reduction);
}
static inline std::tuple<Tensor &,Tensor &> multilabel_margin_loss_forward_out(Tensor & output, Tensor & is_target, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).multilabel_margin_loss_forward_out(output, is_target, self, target, reduction);
}
static inline std::tuple<Tensor,Tensor> multilabel_margin_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).multilabel_margin_loss_forward(self, target, reduction);
}
static inline Tensor & multilabel_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target) {
    return detail::infer_type(self).multilabel_margin_loss_backward_out(grad_input, grad_output, self, target, reduction, is_target);
}
static inline Tensor multilabel_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target) {
    return detail::infer_type(self).multilabel_margin_loss_backward(grad_output, self, target, reduction, is_target);
}
static inline Tensor & nll_loss_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self).nll_loss_out(output, self, target, weight, reduction, ignore_index);
}
static inline Tensor nll_loss(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self).nll_loss(self, target, weight, reduction, ignore_index);
}
static inline std::tuple<Tensor &,Tensor &> nll_loss_forward_out(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self).nll_loss_forward_out(output, total_weight, self, target, weight, reduction, ignore_index);
}
static inline std::tuple<Tensor,Tensor> nll_loss_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self).nll_loss_forward(self, target, weight, reduction, ignore_index);
}
static inline Tensor & nll_loss_backward_out(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) {
    return detail::infer_type(self).nll_loss_backward_out(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight);
}
static inline 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) {
    return detail::infer_type(self).nll_loss_backward(grad_output, self, target, weight, reduction, ignore_index, total_weight);
}
static inline Tensor & nll_loss2d_out(Tensor & output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self).nll_loss2d_out(output, self, target, weight, reduction, ignore_index);
}
static inline Tensor nll_loss2d(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self).nll_loss2d(self, target, weight, reduction, ignore_index);
}
static inline std::tuple<Tensor &,Tensor &> nll_loss2d_forward_out(Tensor & output, Tensor & total_weight, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self).nll_loss2d_forward_out(output, total_weight, self, target, weight, reduction, ignore_index);
}
static inline std::tuple<Tensor,Tensor> nll_loss2d_forward(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
    return detail::infer_type(self).nll_loss2d_forward(self, target, weight, reduction, ignore_index);
}
static inline Tensor & nll_loss2d_backward_out(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) {
    return detail::infer_type(self).nll_loss2d_backward_out(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight);
}
static inline 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) {
    return detail::infer_type(self).nll_loss2d_backward(grad_output, self, target, weight, reduction, ignore_index, total_weight);
}
static inline Tensor & smooth_l1_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).smooth_l1_loss_out(output, self, target, reduction);
}
static inline Tensor smooth_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).smooth_l1_loss(self, target, reduction);
}
static inline Tensor & smooth_l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).smooth_l1_loss_backward_out(grad_input, grad_output, self, target, reduction);
}
static inline Tensor smooth_l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).smooth_l1_loss_backward(grad_output, self, target, reduction);
}
static inline Tensor & soft_margin_loss_out(Tensor & output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).soft_margin_loss_out(output, self, target, reduction);
}
static inline Tensor soft_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).soft_margin_loss(self, target, reduction);
}
static inline Tensor & soft_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).soft_margin_loss_backward_out(grad_input, grad_output, self, target, reduction);
}
static inline Tensor soft_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
    return detail::infer_type(self).soft_margin_loss_backward(grad_output, self, target, reduction);
}
static inline Tensor & elu_out(Tensor & output, const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self).elu_out(output, self, alpha, scale, input_scale);
}
static inline Tensor elu(const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self).elu(self, alpha, scale, input_scale);
}
static inline Tensor & elu_backward_out(Tensor & grad_input, const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output) {
    return detail::infer_type(grad_input).elu_backward_out(grad_input, grad_output, alpha, scale, input_scale, output);
}
static inline Tensor elu_backward(const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output) {
    return detail::infer_type(grad_output).elu_backward(grad_output, alpha, scale, input_scale, output);
}
static inline Tensor & elu_(Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
    return detail::infer_type(self).elu_(self, alpha, scale, input_scale);
}
static inline Tensor & glu_out(Tensor & output, const Tensor & self, int64_t dim) {
    return detail::infer_type(self).glu_out(output, self, dim);
}
static inline Tensor glu(const Tensor & self, int64_t dim) {
    return detail::infer_type(self).glu(self, dim);
}
static inline Tensor & glu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, int64_t dim) {
    return detail::infer_type(self).glu_backward_out(grad_input, grad_output, self, dim);
}
static inline Tensor glu_backward(const Tensor & grad_output, const Tensor & self, int64_t dim) {
    return detail::infer_type(self).glu_backward(grad_output, self, dim);
}
static inline Tensor & hardtanh_out(Tensor & output, const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self).hardtanh_out(output, self, min_val, max_val);
}
static inline Tensor hardtanh(const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self).hardtanh(self, min_val, max_val);
}
static inline Tensor & hardtanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self).hardtanh_backward_out(grad_input, grad_output, self, min_val, max_val);
}
static inline Tensor hardtanh_backward(const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self).hardtanh_backward(grad_output, self, min_val, max_val);
}
static inline Tensor & hardtanh_(Tensor & self, Scalar min_val, Scalar max_val) {
    return detail::infer_type(self).hardtanh_(self, min_val, max_val);
}
static inline Tensor & leaky_relu_out(Tensor & output, const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self).leaky_relu_out(output, self, negative_slope);
}
static inline Tensor leaky_relu(const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self).leaky_relu(self, negative_slope);
}
static inline Tensor & leaky_relu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self).leaky_relu_backward_out(grad_input, grad_output, self, negative_slope);
}
static inline Tensor leaky_relu_backward(const Tensor & grad_output, const Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self).leaky_relu_backward(grad_output, self, negative_slope);
}
static inline Tensor & leaky_relu_(Tensor & self, Scalar negative_slope) {
    return detail::infer_type(self).leaky_relu_(self, negative_slope);
}
static inline Tensor & log_sigmoid_out(Tensor & output, const Tensor & self) {
    return detail::infer_type(self).log_sigmoid_out(output, self);
}
static inline Tensor log_sigmoid(const Tensor & self) {
    return detail::infer_type(self).log_sigmoid(self);
}
static inline std::tuple<Tensor &,Tensor &> log_sigmoid_forward_out(Tensor & output, Tensor & buffer, const Tensor & self) {
    return detail::infer_type(self).log_sigmoid_forward_out(output, buffer, self);
}
static inline std::tuple<Tensor,Tensor> log_sigmoid_forward(const Tensor & self) {
    return detail::infer_type(self).log_sigmoid_forward(self);
}
static inline Tensor & log_sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & buffer) {
    return detail::infer_type(self).log_sigmoid_backward_out(grad_input, grad_output, self, buffer);
}
static inline Tensor log_sigmoid_backward(const Tensor & grad_output, const Tensor & self, const Tensor & buffer) {
    return detail::infer_type(self).log_sigmoid_backward(grad_output, self, buffer);
}
static inline Tensor & rrelu_with_noise_out(Tensor & output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self).rrelu_with_noise_out(output, self, noise, lower, upper, training, generator);
}
static inline Tensor rrelu_with_noise(const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self).rrelu_with_noise(self, noise, lower, upper, training, generator);
}
static inline Tensor & rrelu_with_noise_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training) {
    return detail::infer_type(self).rrelu_with_noise_backward_out(grad_input, grad_output, self, noise, lower, upper, training);
}
static inline Tensor rrelu_with_noise_backward(const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training) {
    return detail::infer_type(self).rrelu_with_noise_backward(grad_output, self, noise, lower, upper, training);
}
static inline Tensor & rrelu_with_noise_(Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, Generator * generator) {
    return detail::infer_type(self).rrelu_with_noise_(self, noise, lower, upper, training, generator);
}
static inline Tensor & softplus_out(Tensor & output, const Tensor & self, Scalar beta, Scalar threshold) {
    return detail::infer_type(self).softplus_out(output, self, beta, threshold);
}
static inline Tensor softplus(const Tensor & self, Scalar beta, Scalar threshold) {
    return detail::infer_type(self).softplus(self, beta, threshold);
}
static inline Tensor & softplus_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output) {
    return detail::infer_type(self).softplus_backward_out(grad_input, grad_output, self, beta, threshold, output);
}
static inline Tensor softplus_backward(const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output) {
    return detail::infer_type(self).softplus_backward(grad_output, self, beta, threshold, output);
}
static inline Tensor & softshrink_out(Tensor & output, const Tensor & self, Scalar lambd) {
    return detail::infer_type(self).softshrink_out(output, self, lambd);
}
static inline Tensor softshrink(const Tensor & self, Scalar lambd) {
    return detail::infer_type(self).softshrink(self, lambd);
}
static inline Tensor & softshrink_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar lambd) {
    return detail::infer_type(self).softshrink_backward_out(grad_input, grad_output, self, lambd);
}
static inline Tensor softshrink_backward(const Tensor & grad_output, const Tensor & self, Scalar lambd) {
    return detail::infer_type(self).softshrink_backward(grad_output, self, lambd);
}
static inline Tensor & adaptive_avg_pool2d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_avg_pool2d_out(output, self, output_size);
}
static inline Tensor adaptive_avg_pool2d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_avg_pool2d(self, output_size);
}
static inline Tensor & adaptive_avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self) {
    return detail::infer_type(self).adaptive_avg_pool2d_backward_out(grad_input, grad_output, self);
}
static inline Tensor adaptive_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self) {
    return detail::infer_type(self).adaptive_avg_pool2d_backward(grad_output, self);
}
static inline Tensor & adaptive_avg_pool3d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_avg_pool3d_out(output, self, output_size);
}
static inline Tensor adaptive_avg_pool3d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_avg_pool3d(self, output_size);
}
static inline Tensor & adaptive_avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self) {
    return detail::infer_type(self).adaptive_avg_pool3d_backward_out(grad_input, grad_output, self);
}
static inline Tensor adaptive_avg_pool3d_backward(const Tensor & grad_output, const Tensor & self) {
    return detail::infer_type(self).adaptive_avg_pool3d_backward(grad_output, self);
}
static inline std::tuple<Tensor &,Tensor &> adaptive_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_max_pool2d_out(output, indices, self, output_size);
}
static inline std::tuple<Tensor,Tensor> adaptive_max_pool2d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_max_pool2d(self, output_size);
}
static inline Tensor & adaptive_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
    return detail::infer_type(self).adaptive_max_pool2d_backward_out(grad_input, grad_output, self, indices);
}
static inline Tensor adaptive_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
    return detail::infer_type(self).adaptive_max_pool2d_backward(grad_output, self, indices);
}
static inline std::tuple<Tensor &,Tensor &> adaptive_max_pool3d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_max_pool3d_out(output, indices, self, output_size);
}
static inline std::tuple<Tensor,Tensor> adaptive_max_pool3d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).adaptive_max_pool3d(self, output_size);
}
static inline Tensor & adaptive_max_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
    return detail::infer_type(self).adaptive_max_pool3d_backward_out(grad_input, grad_output, self, indices);
}
static inline Tensor adaptive_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
    return detail::infer_type(self).adaptive_max_pool3d_backward(grad_output, self, indices);
}
static inline Tensor & avg_pool2d_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool2d_out(output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor avg_pool2d(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor & avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool2d_backward_out(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor avg_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool2d_backward(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor & avg_pool3d_out(Tensor & output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool3d_out(output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor avg_pool3d(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor & avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool3d_backward_out(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline Tensor avg_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, bool ceil_mode, bool count_include_pad) {
    return detail::infer_type(self).avg_pool3d_backward(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad);
}
static inline std::tuple<Tensor &,Tensor &> fractional_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples) {
    return detail::infer_type(self).fractional_max_pool2d_out(output, indices, self, kernel_size, output_size, random_samples);
}
static inline std::tuple<Tensor,Tensor> fractional_max_pool2d(const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & random_samples) {
    return detail::infer_type(self).fractional_max_pool2d(self, kernel_size, output_size, random_samples);
}
static inline Tensor & fractional_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & indices) {
    return detail::infer_type(self).fractional_max_pool2d_backward_out(grad_input, grad_output, self, kernel_size, output_size, indices);
}
static inline Tensor fractional_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList output_size, const Tensor & indices) {
    return detail::infer_type(self).fractional_max_pool2d_backward(grad_output, self, kernel_size, output_size, indices);
}
static inline std::tuple<Tensor &,Tensor &> max_pool2d_with_indices_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self).max_pool2d_with_indices_out(output, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline std::tuple<Tensor,Tensor> max_pool2d_with_indices(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self).max_pool2d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline Tensor & max_pool2d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices) {
    return detail::infer_type(self).max_pool2d_with_indices_backward_out(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
}
static inline Tensor max_pool2d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices) {
    return detail::infer_type(self).max_pool2d_with_indices_backward(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
}
static inline std::tuple<Tensor &,Tensor &> max_pool3d_with_indices_out(Tensor & output, Tensor & indices, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self).max_pool3d_with_indices_out(output, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline std::tuple<Tensor,Tensor> max_pool3d_with_indices(const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode) {
    return detail::infer_type(self).max_pool3d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
}
static inline Tensor & max_pool3d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices) {
    return detail::infer_type(self).max_pool3d_with_indices_backward_out(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
}
static inline Tensor max_pool3d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntList kernel_size, IntList stride, IntList padding, IntList dilation, bool ceil_mode, const Tensor & indices) {
    return detail::infer_type(self).max_pool3d_with_indices_backward(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
}
static inline Tensor & max_unpool2d_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self).max_unpool2d_out(output, self, indices, output_size);
}
static inline Tensor max_unpool2d(const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self).max_unpool2d(self, indices, output_size);
}
static inline Tensor & max_unpool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self).max_unpool2d_backward_out(grad_input, grad_output, self, indices, output_size);
}
static inline Tensor max_unpool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size) {
    return detail::infer_type(self).max_unpool2d_backward(grad_output, self, indices, output_size);
}
static inline Tensor & max_unpool3d_out(Tensor & output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self).max_unpool3d_out(output, self, indices, output_size, stride, padding);
}
static inline Tensor max_unpool3d(const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self).max_unpool3d(self, indices, output_size, stride, padding);
}
static inline Tensor & max_unpool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self).max_unpool3d_backward_out(grad_input, grad_output, self, indices, output_size, stride, padding);
}
static inline Tensor max_unpool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntList output_size, IntList stride, IntList padding) {
    return detail::infer_type(self).max_unpool3d_backward(grad_output, self, indices, output_size, stride, padding);
}
static inline Tensor & reflection_pad1d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).reflection_pad1d_out(output, self, padding);
}
static inline Tensor reflection_pad1d(const Tensor & self, IntList padding) {
    return detail::infer_type(self).reflection_pad1d(self, padding);
}
static inline Tensor & reflection_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).reflection_pad1d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor reflection_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).reflection_pad1d_backward(grad_output, self, padding);
}
static inline Tensor & reflection_pad2d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).reflection_pad2d_out(output, self, padding);
}
static inline Tensor reflection_pad2d(const Tensor & self, IntList padding) {
    return detail::infer_type(self).reflection_pad2d(self, padding);
}
static inline Tensor & reflection_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).reflection_pad2d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor reflection_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).reflection_pad2d_backward(grad_output, self, padding);
}
static inline Tensor & replication_pad1d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad1d_out(output, self, padding);
}
static inline Tensor replication_pad1d(const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad1d(self, padding);
}
static inline Tensor & replication_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad1d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor replication_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad1d_backward(grad_output, self, padding);
}
static inline Tensor & replication_pad2d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad2d_out(output, self, padding);
}
static inline Tensor replication_pad2d(const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad2d(self, padding);
}
static inline Tensor & replication_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad2d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor replication_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad2d_backward(grad_output, self, padding);
}
static inline Tensor & replication_pad3d_out(Tensor & output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad3d_out(output, self, padding);
}
static inline Tensor replication_pad3d(const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad3d(self, padding);
}
static inline Tensor & replication_pad3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad3d_backward_out(grad_input, grad_output, self, padding);
}
static inline Tensor replication_pad3d_backward(const Tensor & grad_output, const Tensor & self, IntList padding) {
    return detail::infer_type(self).replication_pad3d_backward(grad_output, self, padding);
}
static inline Tensor & upsample_linear1d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self).upsample_linear1d_out(output, self, output_size, align_corners);
}
static inline Tensor upsample_linear1d(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self).upsample_linear1d(self, output_size, align_corners);
}
static inline Tensor & upsample_linear1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_input).upsample_linear1d_backward_out(grad_input, grad_output, output_size, input_size, align_corners);
}
static inline Tensor upsample_linear1d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_output).upsample_linear1d_backward(grad_output, output_size, input_size, align_corners);
}
static inline Tensor & upsample_bilinear2d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self).upsample_bilinear2d_out(output, self, output_size, align_corners);
}
static inline Tensor upsample_bilinear2d(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self).upsample_bilinear2d(self, output_size, align_corners);
}
static inline Tensor & upsample_bilinear2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_input).upsample_bilinear2d_backward_out(grad_input, grad_output, output_size, input_size, align_corners);
}
static inline Tensor upsample_bilinear2d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_output).upsample_bilinear2d_backward(grad_output, output_size, input_size, align_corners);
}
static inline Tensor & upsample_trilinear3d_out(Tensor & output, const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self).upsample_trilinear3d_out(output, self, output_size, align_corners);
}
static inline Tensor upsample_trilinear3d(const Tensor & self, IntList output_size, bool align_corners) {
    return detail::infer_type(self).upsample_trilinear3d(self, output_size, align_corners);
}
static inline Tensor & upsample_trilinear3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_input).upsample_trilinear3d_backward_out(grad_input, grad_output, output_size, input_size, align_corners);
}
static inline Tensor upsample_trilinear3d_backward(const Tensor & grad_output, IntList output_size, IntList input_size, bool align_corners) {
    return detail::infer_type(grad_output).upsample_trilinear3d_backward(grad_output, output_size, input_size, align_corners);
}
static inline Tensor & upsample_nearest1d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self).upsample_nearest1d_out(output, self, output_size);
}
static inline Tensor upsample_nearest1d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).upsample_nearest1d(self, output_size);
}
static inline Tensor & upsample_nearest1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_input).upsample_nearest1d_backward_out(grad_input, grad_output, output_size, input_size);
}
static inline Tensor upsample_nearest1d_backward(const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_output).upsample_nearest1d_backward(grad_output, output_size, input_size);
}
static inline Tensor & upsample_nearest2d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self).upsample_nearest2d_out(output, self, output_size);
}
static inline Tensor upsample_nearest2d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).upsample_nearest2d(self, output_size);
}
static inline Tensor & upsample_nearest2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_input).upsample_nearest2d_backward_out(grad_input, grad_output, output_size, input_size);
}
static inline Tensor upsample_nearest2d_backward(const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_output).upsample_nearest2d_backward(grad_output, output_size, input_size);
}
static inline Tensor & upsample_nearest3d_out(Tensor & output, const Tensor & self, IntList output_size) {
    return detail::infer_type(self).upsample_nearest3d_out(output, self, output_size);
}
static inline Tensor upsample_nearest3d(const Tensor & self, IntList output_size) {
    return detail::infer_type(self).upsample_nearest3d(self, output_size);
}
static inline Tensor & upsample_nearest3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_input).upsample_nearest3d_backward_out(grad_input, grad_output, output_size, input_size);
}
static inline Tensor upsample_nearest3d_backward(const Tensor & grad_output, IntList output_size, IntList input_size) {
    return detail::infer_type(grad_output).upsample_nearest3d_backward(grad_output, output_size, input_size);
}
static inline Tensor & sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output) {
    return detail::infer_type(grad_input).sigmoid_backward_out(grad_input, grad_output, output);
}
static inline Tensor sigmoid_backward(const Tensor & grad_output, const Tensor & output) {
    return detail::infer_type(grad_output).sigmoid_backward(grad_output, output);
}
static inline Tensor & tanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output) {
    return detail::infer_type(grad_input).tanh_backward_out(grad_input, grad_output, output);
}
static inline Tensor tanh_backward(const Tensor & grad_output, const Tensor & output) {
    return detail::infer_type(grad_output).tanh_backward(grad_output, output);
}
static inline Tensor & thnn_conv_transpose2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_transpose2d_out(output, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline Tensor thnn_conv_transpose2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_transpose2d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_transpose2d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_transpose2d_forward_out(output, columns, ones, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_transpose2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_transpose2d_forward(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_transpose2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & columns, const Tensor & ones) {
    return detail::infer_type(self).thnn_conv_transpose2d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, columns, ones);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_transpose2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask) {
    return detail::infer_type(self).thnn_conv_transpose2d_backward(grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, columns, ones, output_mask);
}
static inline Tensor & thnn_conv_transpose3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_transpose3d_out(output, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline Tensor thnn_conv_transpose3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_transpose3d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_transpose3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_transpose3d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_transpose3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList output_padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_transpose3d_forward(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_transpose3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & finput, const Tensor & fgrad_input) {
    return detail::infer_type(self).thnn_conv_transpose3d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, finput, fgrad_input);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_transpose3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList output_padding, IntList dilation, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
    return detail::infer_type(self).thnn_conv_transpose3d_backward(grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, finput, fgrad_input, output_mask);
}
static inline Tensor & thnn_conv2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self).thnn_conv2d_out(output, self, weight, kernel_size, bias, stride, padding);
}
static inline Tensor thnn_conv2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self).thnn_conv2d(self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv2d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self).thnn_conv2d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self).thnn_conv2d_forward(self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input) {
    return detail::infer_type(self).thnn_conv2d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
    return detail::infer_type(self).thnn_conv2d_backward(grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input, output_mask);
}
static inline Tensor & thnn_conv_depthwise2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_depthwise2d_out(output, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor thnn_conv_depthwise2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_depthwise2d(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor & thnn_conv_depthwise2d_forward_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_depthwise2d_forward_out(output, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor thnn_conv_depthwise2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_depthwise2d_forward(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &> thnn_conv_depthwise2d_backward_out(Tensor & grad_input, Tensor & grad_weight, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_depthwise2d_backward_out(grad_input, grad_weight, grad_output, self, weight, kernel_size, stride, padding, dilation);
}
static inline std::tuple<Tensor,Tensor> thnn_conv_depthwise2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, std::array<bool,2> output_mask) {
    return detail::infer_type(self).thnn_conv_depthwise2d_backward(grad_output, self, weight, kernel_size, stride, padding, dilation, output_mask);
}
static inline Tensor & thnn_conv3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self).thnn_conv3d_out(output, self, weight, kernel_size, bias, stride, padding);
}
static inline Tensor thnn_conv3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self).thnn_conv3d(self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self).thnn_conv3d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding) {
    return detail::infer_type(self).thnn_conv3d_forward(self, weight, kernel_size, bias, stride, padding);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input) {
    return detail::infer_type(self).thnn_conv3d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
    return detail::infer_type(self).thnn_conv3d_backward(grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input, output_mask);
}
static inline Tensor & thnn_conv_dilated2d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_dilated2d_out(output, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor thnn_conv_dilated2d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_dilated2d(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_dilated2d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_dilated2d_forward_out(output, columns, ones, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_dilated2d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_dilated2d_forward(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_dilated2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones) {
    return detail::infer_type(self).thnn_conv_dilated2d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, dilation, columns, ones);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_dilated2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask) {
    return detail::infer_type(self).thnn_conv_dilated2d_backward(grad_output, self, weight, kernel_size, stride, padding, dilation, columns, ones, output_mask);
}
static inline Tensor & thnn_conv_dilated3d_out(Tensor & output, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_dilated3d_out(output, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline Tensor thnn_conv_dilated3d(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_dilated3d(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_dilated3d_forward_out(Tensor & output, Tensor & columns, Tensor & ones, const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_dilated3d_forward_out(output, columns, ones, self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_dilated3d_forward(const Tensor & self, const Tensor & weight, IntList kernel_size, const Tensor & bias, IntList stride, IntList padding, IntList dilation) {
    return detail::infer_type(self).thnn_conv_dilated3d_forward(self, weight, kernel_size, bias, stride, padding, dilation);
}
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv_dilated3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones) {
    return detail::infer_type(self).thnn_conv_dilated3d_backward_out(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, dilation, columns, ones);
}
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv_dilated3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntList kernel_size, IntList stride, IntList padding, IntList dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask) {
    return detail::infer_type(self).thnn_conv_dilated3d_backward(grad_output, self, weight, kernel_size, stride, padding, dilation, columns, ones, output_mask);
}

}
