#pragma once

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

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

namespace at {

using native::tensor;

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::vector<Tensor> align_tensors(TensorList tensors);
static inline bool _use_cudnn_ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank);
static inline std::tuple<Tensor,Tensor> _cudnn_ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank, bool deterministic, bool zero_infinity);
static inline bool _use_cudnn_rnn_flatten_weight();
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, IntArrayRef 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, IntArrayRef 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 int64_t _debug_has_internal_overlap(const Tensor & self);
static inline std::tuple<Tensor,Tensor> _fused_dropout(const Tensor & self, double p, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor _masked_scale(const Tensor & self, const Tensor & mask, double scale);
static inline std::tuple<Tensor,Tensor> _sobol_engine_draw(const Tensor & quasi, int64_t n, const Tensor & sobolstate, int64_t dimension, int64_t num_generated, c10::optional<ScalarType> dtype);
static inline Tensor & _sobol_engine_ff_(Tensor & self, int64_t n, const Tensor & sobolstate, int64_t dimension, int64_t num_generated);
static inline Tensor & _sobol_engine_scramble_(Tensor & self, const Tensor & ltm, int64_t dimension);
static inline Tensor & _sobol_engine_initialize_state_(Tensor & self, int64_t dimension);
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 & out, const Tensor & self);
static inline Tensor absolute(const Tensor & self);
static inline Tensor & absolute_(Tensor & self);
static inline Tensor & absolute_out(Tensor & out, const Tensor & self);
static inline Tensor angle(const Tensor & self);
static inline Tensor & angle_out(Tensor & out, const Tensor & self);
static inline Tensor real(const Tensor & self);
static inline Tensor imag(const Tensor & self);
static inline Tensor copy_real(const Tensor & self);
static inline Tensor & copy_real_out(Tensor & out, const Tensor & self);
static inline Tensor copy_imag(const Tensor & self);
static inline Tensor & copy_imag_out(Tensor & out, const Tensor & self);
static inline Tensor conj(const Tensor & self);
static inline Tensor & conj_out(Tensor & out, const Tensor & self);
static inline Tensor acos(const Tensor & self);
static inline Tensor & acos_(Tensor & self);
static inline Tensor & acos_out(Tensor & out, const Tensor & self);
static inline Tensor avg_pool1d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, bool ceil_mode=false, bool count_include_pad=true);
static inline Tensor adaptive_avg_pool1d(const Tensor & self, IntArrayRef output_size);
static inline std::tuple<Tensor,Tensor> adaptive_max_pool1d(const Tensor & self, IntArrayRef output_size);
static inline Tensor add(const Tensor & self, const Tensor & other, Scalar alpha=1);
static inline Tensor & add_out(Tensor & out, 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 & out, 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 & out, const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor affine_grid_generator(const Tensor & theta, IntArrayRef size, bool align_corners);
static inline Tensor affine_grid_generator_backward(const Tensor & grad, IntArrayRef size, bool align_corners);
static inline Tensor all(const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor & all_out(Tensor & out, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor all(const Tensor & self, Dimname dim, bool keepdim=false);
static inline Tensor & all_out(Tensor & out, const Tensor & self, Dimname 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 & out, const Tensor & self, int64_t dim, bool keepdim=false);
static inline Tensor any(const Tensor & self, Dimname dim, bool keepdim=false);
static inline Tensor & any_out(Tensor & out, const Tensor & self, Dimname dim, bool keepdim=false);
static inline Tensor arange(Scalar end, const TensorOptions & options={});
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 & out, Scalar end);
static inline Tensor & arange_out(Tensor & out, Scalar start, Scalar end, Scalar step=1);
static inline Tensor _dim_arange(const Tensor & like, int64_t dim);
static inline Tensor argmax(const Tensor & self, c10::optional<int64_t> dim=c10::nullopt, bool keepdim=false);
static inline Tensor argmin(const Tensor & self, c10::optional<int64_t> dim=c10::nullopt, bool keepdim=false);
static inline Tensor as_strided(const Tensor & self, IntArrayRef size, IntArrayRef stride, c10::optional<int64_t> storage_offset=c10::nullopt);
static inline Tensor & as_strided_(Tensor & self, IntArrayRef size, IntArrayRef stride, c10::optional<int64_t> storage_offset=c10::nullopt);
static inline Tensor asin(const Tensor & self);
static inline Tensor & asin_(Tensor & self);
static inline Tensor & asin_out(Tensor & out, const Tensor & self);
static inline Tensor atan(const Tensor & self);
static inline Tensor & atan_(Tensor & self);
static inline Tensor & atan_out(Tensor & out, 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 & out, 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 quantized_batch_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & mean, const Tensor & var, double eps, double output_scale, int64_t output_zero_point);
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,int64_t> _batch_norm_impl_index(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 std::tuple<Tensor,Tensor,Tensor> _batch_norm_impl_index_backward(int64_t impl_index, 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_transform, bool train, double eps, std::array<bool,3> output_mask, const Tensor & reservedSpace);
static inline Tensor bernoulli(const Tensor & self, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor & bernoulli_out(Tensor & out, const Tensor & self, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor bernoulli(const Tensor & self, double p, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor bilinear(const Tensor & input1, const Tensor & input2, const Tensor & weight, const Tensor & bias);
static inline Tensor binary_cross_entropy(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=at::Reduction::Mean);
static inline Tensor & binary_cross_entropy_out(Tensor & out, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=at::Reduction::Mean);
static inline Tensor binary_cross_entropy_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=at::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=at::Reduction::Mean);
static inline Tensor binary_cross_entropy_with_logits(const Tensor & self, const Tensor & target, const Tensor & weight={}, const Tensor & pos_weight={}, int64_t reduction=at::Reduction::Mean);
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=at::Reduction::Mean);
static inline Tensor bincount(const Tensor & self, const Tensor & weights={}, int64_t minlength=0);
static inline Tensor bitwise_not(const Tensor & self);
static inline Tensor & bitwise_not_out(Tensor & out, const Tensor & self);
static inline Tensor logical_not(const Tensor & self);
static inline Tensor & logical_not_out(Tensor & out, const Tensor & self);
static inline Tensor logical_xor(const Tensor & self, const Tensor & other);
static inline Tensor & logical_xor_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor logical_and(const Tensor & self, const Tensor & other);
static inline Tensor & logical_and_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor logical_or(const Tensor & self, const Tensor & other);
static inline Tensor & logical_or_out(Tensor & out, const Tensor & self, const Tensor & other);
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(const Tensor & self, const Tensor & mat2, bool deterministic=false);
static inline Tensor & bmm_out(Tensor & out, const Tensor & self, const Tensor & mat2);
static inline Tensor & _bmm_out(Tensor & out, const Tensor & self, const Tensor & mat2, bool deterministic=false);
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 & out, TensorList tensors, int64_t dim=0);
static inline Tensor cat(TensorList tensors, Dimname dim);
static inline Tensor & cat_out(Tensor & out, TensorList tensors, Dimname dim);
static inline Tensor block_diag(TensorList tensors);
static inline Tensor ceil(const Tensor & self);
static inline Tensor & ceil_(Tensor & self);
static inline Tensor & ceil_out(Tensor & out, 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 & out, 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 & out, 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 & out, const Tensor & self, Scalar min);
static inline bool cudnn_is_acceptable(const Tensor & self);
static inline Tensor constant_pad_nd(const Tensor & self, IntArrayRef pad, Scalar value=0);
static inline Tensor convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding, int64_t groups);
static inline Tensor convolution_overrideable(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding, int64_t groups);
static inline std::tuple<Tensor,Tensor,Tensor> convolution_backward_overrideable(const Tensor & grad_output, const Tensor & input, const Tensor & weight, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding, int64_t groups, std::array<bool,3> output_mask);
static inline Tensor _convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef 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, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef 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, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef 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={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef dilation=1, int64_t groups=1);
static inline Tensor conv2d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef dilation=1, int64_t groups=1);
static inline Tensor conv3d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef 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={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef output_padding=0, int64_t groups=1, IntArrayRef dilation=1);
static inline Tensor conv_transpose2d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef output_padding=0, int64_t groups=1, IntArrayRef dilation=1);
static inline Tensor conv_transpose3d(const Tensor & input, const Tensor & weight, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef output_padding=0, int64_t groups=1, IntArrayRef dilation=1);
static inline Tensor _copy_from(const Tensor & self, const Tensor & dst, bool non_blocking=false);
static inline Tensor cos(const Tensor & self);
static inline Tensor & cos_(Tensor & self);
static inline Tensor & cos_out(Tensor & out, const Tensor & self);
static inline Tensor cosh(const Tensor & self);
static inline Tensor & cosh_(Tensor & self);
static inline Tensor & cosh_out(Tensor & out, 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=at::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,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, const Tensor & reserveSpace);
static inline Tensor cudnn_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_convolution(const Tensor & self, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_convolution_backward_input(IntArrayRef self_size, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline std::tuple<Tensor,Tensor> cudnn_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,2> output_mask);
static inline Tensor cudnn_convolution_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_convolution_transpose(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_convolution_transpose(const Tensor & self, const Tensor & weight, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline std::tuple<Tensor,Tensor> cudnn_convolution_transpose_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,2> output_mask);
static inline Tensor cudnn_convolution_transpose_backward_input(const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor cudnn_convolution_transpose_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef 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 std::tuple<Tensor,Tensor> cummax(const Tensor & self, int64_t dim);
static inline std::tuple<Tensor &,Tensor &> cummax_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim);
static inline std::tuple<Tensor,Tensor> cummax(const Tensor & self, Dimname dim);
static inline std::tuple<Tensor &,Tensor &> cummax_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim);
static inline void _cummax_helper(const Tensor & self, Tensor & values, Tensor & indices, int64_t dim);
static inline std::tuple<Tensor,Tensor> cummin(const Tensor & self, int64_t dim);
static inline std::tuple<Tensor &,Tensor &> cummin_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim);
static inline std::tuple<Tensor,Tensor> cummin(const Tensor & self, Dimname dim);
static inline std::tuple<Tensor &,Tensor &> cummin_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim);
static inline void _cummin_helper(const Tensor & self, Tensor & values, Tensor & indices, int64_t dim);
static inline Tensor cumprod(const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & cumprod_out(Tensor & out, const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor cumprod(const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & cumprod_out(Tensor & out, const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor cumsum(const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & cumsum_out(Tensor & out, const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor cumsum(const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & cumsum_out(Tensor & out, const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank=0, int64_t reduction=at::Reduction::Mean, bool zero_infinity=false);
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=at::Reduction::Mean, bool zero_infinity=false);
static inline std::tuple<Tensor,Tensor> _ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank=0, bool zero_infinity=false);
static inline Tensor _ctc_loss_backward(const Tensor & grad, const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, const Tensor & neg_log_likelihood, const Tensor & log_alpha, int64_t blank, bool zero_infinity=false);
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 diagonal(const Tensor & self, Dimname outdim, Dimname dim1, Dimname dim2, int64_t offset=0);
static inline Tensor div(const Tensor & self, const Tensor & other);
static inline Tensor & div_out(Tensor & out, 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 & out, 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_output, 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, const Tensor & per_sample_weights={}, bool include_last_offset=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, const Tensor & per_sample_weights={}, bool include_last_offset=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, const Tensor & per_sample_weights);
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, const Tensor & per_sample_weights);
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, const Tensor & per_sample_weights);
static inline Tensor _embedding_bag_per_sample_weights_backward(const Tensor & grad, const Tensor & weight, const Tensor & indices, const Tensor & offsets, const Tensor & offset2bag, int64_t mode);
static inline Tensor empty(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor empty(IntArrayRef size, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor _empty_affine_quantized(IntArrayRef size, const TensorOptions & options={}, double scale=1, int64_t zero_point=0, c10::optional<MemoryFormat> memory_format=MemoryFormat::Contiguous);
static inline Tensor _empty_per_channel_affine_quantized(IntArrayRef size, const Tensor & scales, const Tensor & zero_points, int64_t axis, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=MemoryFormat::Contiguous);
static inline Tensor & empty_out(Tensor & out, IntArrayRef size, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor empty_like(const Tensor & self, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor empty_strided(IntArrayRef size, IntArrayRef stride, const TensorOptions & options={});
static inline Tensor erf(const Tensor & self);
static inline Tensor & erf_(Tensor & self);
static inline Tensor & erf_out(Tensor & out, const Tensor & self);
static inline Tensor erfc(const Tensor & self);
static inline Tensor & erfc_(Tensor & self);
static inline Tensor & erfc_out(Tensor & out, const Tensor & self);
static inline Tensor exp(const Tensor & self);
static inline Tensor & exp_(Tensor & self);
static inline Tensor & exp_out(Tensor & out, const Tensor & self);
static inline Tensor expm1(const Tensor & self);
static inline Tensor & expm1_(Tensor & self);
static inline Tensor & expm1_out(Tensor & out, 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 & out, int64_t n);
static inline Tensor & eye_out(Tensor & out, 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 flatten(const Tensor & self, int64_t start_dim, int64_t end_dim, Dimname out_dim);
static inline Tensor flatten(const Tensor & self, Dimname start_dim, Dimname end_dim, Dimname out_dim);
static inline Tensor flatten(const Tensor & self, DimnameList dims, Dimname out_dim);
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 & out, const Tensor & self);
static inline Tensor floor_divide(const Tensor & self, const Tensor & other);
static inline Tensor & floor_divide_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor floor_divide(const Tensor & self, Scalar other);
static inline Tensor frac(const Tensor & self);
static inline Tensor & frac_(Tensor & self);
static inline Tensor & frac_out(Tensor & out, const Tensor & self);
static inline Tensor full(IntArrayRef size, Scalar fill_value, c10::optional<DimnameList> names, const TensorOptions & options={});
static inline Tensor full(IntArrayRef size, Scalar fill_value, const TensorOptions & options={});
static inline Tensor & full_out(Tensor & out, IntArrayRef size, Scalar fill_value);
static inline Tensor full_like(const Tensor & self, Scalar fill_value, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor from_file(std::string filename, c10::optional<bool> shared=c10::nullopt, c10::optional<int64_t> size=0, const TensorOptions & options={});
static inline Tensor grid_sampler(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
static inline Tensor grid_sampler_2d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
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, bool align_corners);
static inline Tensor grid_sampler_3d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
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, bool align_corners);
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=at::Reduction::Mean);
static inline Tensor ger(const Tensor & self, const Tensor & vec2);
static inline Tensor & ger_out(Tensor & out, const Tensor & self, const Tensor & vec2);
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, IntArrayRef signal_sizes={});
static inline Tensor _fft_with_size(const Tensor & self, int64_t signal_ndim, bool complex_input, bool complex_output, bool inverse, IntArrayRef checked_signal_sizes, bool normalized, bool onesided, IntArrayRef output_sizes);
static inline int64_t _cufft_get_plan_cache_size(int64_t device_index);
static inline int64_t _cufft_get_plan_cache_max_size(int64_t device_index);
static inline void _cufft_set_plan_cache_max_size(int64_t device_index, int64_t max_size);
static inline void _cufft_clear_plan_cache(int64_t device_index);
static inline Tensor index(const Tensor & self, TensorList indices);
static inline Tensor index_copy(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & source);
static inline Tensor index_copy(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & source);
static inline Tensor & index_put_(Tensor & self, TensorList indices, const Tensor & values, bool accumulate=false);
static inline Tensor index_put(const Tensor & self, TensorList indices, const Tensor & values, bool accumulate=false);
static inline Tensor & _index_put_impl_(Tensor & self, TensorList indices, const Tensor & values, bool accumulate=false, bool unsafe=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 & out, 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 Tensor isnan(const Tensor & self);
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=at::Reduction::Mean, bool log_target=false);
static inline Tensor kl_div_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction=at::Reduction::Mean, bool log_target=false);
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 std::tuple<Tensor,Tensor> kthvalue(const Tensor & self, int64_t k, Dimname dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> kthvalue_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, Dimname dim, bool keepdim=false);
static inline Tensor layer_norm(const Tensor & input, IntArrayRef normalized_shape, const Tensor & weight={}, const Tensor & bias={}, double eps=1e-05, bool cudnn_enable=true);
static inline std::tuple<Tensor,Tensor,Tensor> native_layer_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, int64_t M, int64_t N, double eps);
static inline std::tuple<Tensor,Tensor,Tensor> native_layer_norm_backward(const Tensor & grad_out, const Tensor & input, const Tensor & mean, const Tensor & rstd, const Tensor & weight, int64_t M, int64_t N, std::array<bool,3> output_mask);
static inline Tensor quantized_layer_norm(const Tensor & input, IntArrayRef normalized_shape, const Tensor & weight, const Tensor & bias, double eps, double output_scale, int64_t output_zero_point);
static inline Tensor linear(const Tensor & input, const Tensor & weight, const Tensor & bias={});
static inline Tensor mkldnn_linear(const Tensor & input, const Tensor & weight, const Tensor & bias={});
static inline Tensor fbgemm_linear_int8_weight_fp32_activation(const Tensor & input, const Tensor & weight, const Tensor & packed, const Tensor & col_offsets, Scalar weight_scale, Scalar weight_zero_point, const Tensor & bias);
static inline Tensor fbgemm_linear_int8_weight(const Tensor & input, const Tensor & weight, const Tensor & packed, const Tensor & col_offsets, Scalar weight_scale, Scalar weight_zero_point, const Tensor & bias);
static inline std::tuple<Tensor,Tensor,double,int64_t> fbgemm_linear_quantize_weight(const Tensor & input);
static inline Tensor fbgemm_pack_gemm_matrix_fp16(const Tensor & input);
static inline Tensor fbgemm_linear_fp16_weight_fp32_activation(const Tensor & input, const Tensor & packed_weight, const Tensor & bias);
static inline Tensor fbgemm_linear_fp16_weight(const Tensor & input, const Tensor & packed_weight, const Tensor & bias);
static inline Tensor fbgemm_pack_quantized_matrix(const Tensor & input);
static inline Tensor fbgemm_pack_quantized_matrix(const Tensor & input, int64_t K, int64_t N);
static inline Tensor linspace(Scalar start, Scalar end, int64_t steps=100, const TensorOptions & options={});
static inline Tensor & linspace_out(Tensor & out, Scalar start, Scalar end, int64_t steps=100);
static inline Tensor log(const Tensor & self);
static inline Tensor & log_(Tensor & self);
static inline Tensor & log_out(Tensor & out, const Tensor & self);
static inline Tensor log10(const Tensor & self);
static inline Tensor & log10_(Tensor & self);
static inline Tensor & log10_out(Tensor & out, const Tensor & self);
static inline Tensor log1p(const Tensor & self);
static inline Tensor & log1p_(Tensor & self);
static inline Tensor & log1p_out(Tensor & out, const Tensor & self);
static inline Tensor log2(const Tensor & self);
static inline Tensor & log2_(Tensor & self);
static inline Tensor & log2_out(Tensor & out, const Tensor & self);
static inline Tensor logdet(const Tensor & self);
static inline Tensor logspace(Scalar start, Scalar end, int64_t steps=100, double base=10.0, const TensorOptions & options={});
static inline Tensor & logspace_out(Tensor & out, Scalar start, Scalar end, int64_t steps=100, double base=10.0);
static inline Tensor log_softmax(const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor log_softmax(const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype=c10::nullopt);
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, IntArrayRef dim, bool keepdim=false);
static inline Tensor & logsumexp_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim=false);
static inline Tensor logsumexp(const Tensor & self, DimnameList dim, bool keepdim=false);
static inline Tensor & logsumexp_out(Tensor & out, const Tensor & self, DimnameList 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=at::Reduction::Mean);
static inline Tensor matmul(const Tensor & self, const Tensor & other);
static inline Tensor & matmul_out(Tensor & out, 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, IntArrayRef dim, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> max(const Tensor & self, Dimname dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> max_out(Tensor & max, Tensor & max_values, const Tensor & self, Dimname dim, bool keepdim=false);
static inline Tensor max_values(const Tensor & self, DimnameList dim, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> max_pool1d_with_indices(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef dilation=1, bool ceil_mode=false);
static inline Tensor max_pool1d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef dilation=1, bool ceil_mode=false);
static inline Tensor max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef dilation=1, bool ceil_mode=false);
static inline Tensor mkldnn_max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef dilation=1, bool ceil_mode=false);
static inline Tensor quantized_max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef dilation=1, bool ceil_mode=false);
static inline Tensor max_pool3d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef dilation=1, bool ceil_mode=false);
static inline Tensor mean(const Tensor & self, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor mean(const Tensor & self, IntArrayRef dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & mean_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor mean(const Tensor & self, DimnameList dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & mean_out(Tensor & out, const Tensor & self, DimnameList dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
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> median(const Tensor & self, Dimname dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> median_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname 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, IntArrayRef dim, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> min(const Tensor & self, Dimname dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> min_out(Tensor & min, Tensor & min_indices, const Tensor & self, Dimname dim, bool keepdim=false);
static inline Tensor min_values(const Tensor & self, DimnameList dim, bool keepdim=false);
static inline Tensor mkldnn_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups);
static inline Tensor mkldnn_convolution_backward_input(IntArrayRef self_size, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool bias_defined);
static inline std::tuple<Tensor,Tensor> mkldnn_convolution_backward_weights(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef 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, IntArrayRef padding, IntArrayRef stride, IntArrayRef 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, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor miopen_convolution_backward_input(IntArrayRef self_size, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef 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, IntArrayRef padding, IntArrayRef stride, IntArrayRef 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(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor miopen_convolution_transpose(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef 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, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef 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, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor miopen_convolution_transpose_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor miopen_depthwise_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline Tensor miopen_depthwise_convolution_backward_input(IntArrayRef self_size, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline std::tuple<Tensor,Tensor,Tensor> miopen_depthwise_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask);
static inline Tensor miopen_depthwise_convolution_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic);
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> miopen_rnn(const Tensor & input, TensorList weight, int64_t weight_stride0, 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, IntArrayRef batch_sizes, const Tensor & dropout_state);
static inline std::tuple<Tensor,Tensor,Tensor,std::vector<Tensor>> miopen_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, IntArrayRef batch_sizes, const Tensor & dropout_state, const Tensor & reserve, std::array<bool,4> output_mask);
static inline Tensor mm(const Tensor & self, const Tensor & mat2);
static inline Tensor & mm_out(Tensor & out, 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 std::tuple<Tensor,Tensor> mode(const Tensor & self, Dimname dim, bool keepdim=false);
static inline std::tuple<Tensor &,Tensor &> mode_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim, bool keepdim=false);
static inline Tensor mul(const Tensor & self, const Tensor & other);
static inline Tensor & mul_out(Tensor & out, 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 & out, 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 Tensor narrow(const Tensor & self, int64_t dim, const Tensor & 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_out(Tensor & out, Tensor & save_mean, Tensor & save_invstd, 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> batch_norm_stats(const Tensor & input, double eps);
static inline Tensor batch_norm_elemt(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & mean, const Tensor & invstd, double eps);
static inline Tensor & batch_norm_elemt_out(Tensor & out, const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & mean, const Tensor & invstd, double eps);
static inline std::tuple<Tensor,Tensor> batch_norm_gather_stats(const Tensor & input, const Tensor & mean, const Tensor & invstd, const Tensor & running_mean, const Tensor & running_var, double momentum, double eps, int64_t count);
static inline std::tuple<Tensor,Tensor> batch_norm_gather_stats_with_counts(const Tensor & input, const Tensor & mean, const Tensor & invstd, const Tensor & running_mean, const Tensor & running_var, double momentum, double eps, const Tensor & counts);
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 std::tuple<Tensor,Tensor,Tensor,Tensor> batch_norm_backward_reduce(const Tensor & grad_out, const Tensor & input, const Tensor & mean, const Tensor & invstd, const Tensor & weight, bool input_g, bool weight_g, bool bias_g);
static inline Tensor batch_norm_backward_elemt(const Tensor & grad_out, const Tensor & input, const Tensor & mean, const Tensor & invstd, const Tensor & weight, const Tensor & mean_dy, const Tensor & mean_dy_xmu);
static inline std::tuple<Tensor,Tensor> batch_norm_update_stats(const Tensor & input, const Tensor & running_mean, const Tensor & running_var, double momentum);
static inline bool _nnpack_available();
static inline Tensor _nnpack_spatial_convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride=1);
static inline std::tuple<Tensor,Tensor,Tensor> _nnpack_spatial_convolution_backward(const Tensor & input, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, std::array<bool,3> output_mask);
static inline Tensor _nnpack_spatial_convolution_backward_input(const Tensor & input, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding);
static inline Tensor _nnpack_spatial_convolution_backward_weight(const Tensor & input, IntArrayRef weightsize, const Tensor & grad_output, IntArrayRef padding);
static inline Tensor ones(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options={});
static inline Tensor ones(IntArrayRef size, const TensorOptions & options={});
static inline Tensor & ones_out(Tensor & out, IntArrayRef size);
static inline Tensor ones_like(const Tensor & self, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor pairwise_distance(const Tensor & x1, const Tensor & x2, double p=2, double eps=1e-06, bool keepdim=false);
static inline Tensor cdist(const Tensor & x1, const Tensor & x2, double p=2, c10::optional<int64_t> compute_mode=c10::nullopt);
static inline Tensor _cdist_forward(const Tensor & x1, const Tensor & x2, double p, c10::optional<int64_t> compute_mode);
static inline Tensor _cdist_backward(const Tensor & grad, const Tensor & x1, const Tensor & x2, double p, const Tensor & cdist);
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 pinverse(const Tensor & self, double rcond=1e-15);
static inline Tensor poisson_nll_loss(const Tensor & input, const Tensor & target, bool log_input, bool full, double eps, int64_t reduction);
static inline Tensor scalar_tensor(Scalar s, const TensorOptions & options={});
static inline Tensor rand(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options={});
static inline Tensor rand(IntArrayRef size, c10::optional<Generator> generator, c10::optional<DimnameList> names, const TensorOptions & options={});
static inline Tensor rand(IntArrayRef size, const TensorOptions & options={});
static inline Tensor rand(IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options={});
static inline Tensor & rand_out(Tensor & out, IntArrayRef size);
static inline Tensor & rand_out(Tensor & out, IntArrayRef size, c10::optional<Generator> generator);
static inline Tensor rand_like(const Tensor & self, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor randint(int64_t high, IntArrayRef size, const TensorOptions & options={});
static inline Tensor randint(int64_t high, IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options={});
static inline Tensor randint(int64_t low, int64_t high, IntArrayRef size, const TensorOptions & options={});
static inline Tensor randint(int64_t low, int64_t high, IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options={});
static inline Tensor & randint_out(Tensor & out, int64_t high, IntArrayRef size);
static inline Tensor & randint_out(Tensor & out, int64_t high, IntArrayRef size, c10::optional<Generator> generator);
static inline Tensor & randint_out(Tensor & out, int64_t low, int64_t high, IntArrayRef size);
static inline Tensor & randint_out(Tensor & out, int64_t low, int64_t high, IntArrayRef size, c10::optional<Generator> generator);
static inline Tensor randint_like(const Tensor & self, int64_t high, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor randint_like(const Tensor & self, int64_t low, int64_t high, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor randn(IntArrayRef size, const TensorOptions & options={});
static inline Tensor randn(IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options={});
static inline Tensor randn(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options={});
static inline Tensor randn(IntArrayRef size, c10::optional<Generator> generator, c10::optional<DimnameList> names, const TensorOptions & options={});
static inline Tensor & randn_out(Tensor & out, IntArrayRef size);
static inline Tensor & randn_out(Tensor & out, IntArrayRef size, c10::optional<Generator> generator);
static inline Tensor randn_like(const Tensor & self, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor randperm(int64_t n, const TensorOptions & options={});
static inline Tensor randperm(int64_t n, c10::optional<Generator> generator, const TensorOptions & options={});
static inline Tensor & randperm_out(Tensor & out, int64_t n);
static inline Tensor & randperm_out(Tensor & out, int64_t n, c10::optional<Generator> generator);
static inline Tensor range(Scalar start, Scalar end, Scalar step=1, const TensorOptions & options={});
static inline Tensor range(Scalar start, Scalar end, const TensorOptions & options={});
static inline Tensor & range_out(Tensor & out, Scalar start, Scalar end, Scalar step=1);
static inline Tensor reciprocal(const Tensor & self);
static inline Tensor & reciprocal_(Tensor & self);
static inline Tensor & reciprocal_out(Tensor & out, const Tensor & self);
static inline Tensor neg(const Tensor & self);
static inline Tensor & neg_(Tensor & self);
static inline Tensor & neg_out(Tensor & out, const Tensor & self);
static inline Tensor repeat_interleave(const Tensor & repeats);
static inline Tensor repeat_interleave(const Tensor & self, const Tensor & repeats, c10::optional<int64_t> dim=c10::nullopt);
static inline Tensor repeat_interleave(const Tensor & self, int64_t repeats, c10::optional<int64_t> dim=c10::nullopt);
static inline Tensor reshape(const Tensor & self, IntArrayRef shape);
static inline Tensor _mkldnn_reshape(const Tensor & self, IntArrayRef shape);
static inline Tensor round(const Tensor & self);
static inline Tensor & round_(Tensor & self);
static inline Tensor & round_out(Tensor & out, const Tensor & self);
static inline Tensor rrelu(const Tensor & self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor & rrelu_(Tensor & self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, c10::optional<Generator> generator=c10::nullopt);
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 gelu(const Tensor & self);
static inline Tensor gelu_backward(const Tensor & grad, const Tensor & self);
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 & out, const Tensor & self);
static inline Tensor select(const Tensor & self, Dimname dim, int64_t index);
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 & out, const Tensor & self);
static inline Tensor sin(const Tensor & self);
static inline Tensor & sin_(Tensor & self);
static inline Tensor & sin_out(Tensor & out, const Tensor & self);
static inline Tensor sinh(const Tensor & self);
static inline Tensor & sinh_(Tensor & self);
static inline Tensor & sinh_out(Tensor & out, 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 int64_t size(const Tensor & self, Dimname 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, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor softmax(const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype=c10::nullopt);
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 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, IntArrayRef 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 squeeze(const Tensor & self, Dimname 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 & out, 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 & out, TensorList tensors, int64_t dim=0);
static inline Tensor stft(const Tensor & self, int64_t n_fft, c10::optional<int64_t> hop_length=c10::nullopt, c10::optional<int64_t> win_length=c10::nullopt, const Tensor & window={}, bool normalized=false, bool onesided=true);
static inline Tensor istft(const Tensor & self, int64_t n_fft, c10::optional<int64_t> hop_length=c10::nullopt, c10::optional<int64_t> win_length=c10::nullopt, const Tensor & window={}, bool center=true, bool normalized=false, bool onesided=true, c10::optional<int64_t> length=c10::nullopt);
static inline int64_t stride(const Tensor & self, int64_t dim);
static inline int64_t stride(const Tensor & self, Dimname dim);
static inline Tensor sum(const Tensor & self, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor sum(const Tensor & self, IntArrayRef dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor sum(const Tensor & self, DimnameList dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & sum_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & sum_out(Tensor & out, const Tensor & self, DimnameList dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor sqrt(const Tensor & self);
static inline Tensor & sqrt_(Tensor & self);
static inline Tensor & sqrt_out(Tensor & out, const Tensor & self);
static inline Tensor square(const Tensor & self);
static inline Tensor & square_(Tensor & self);
static inline Tensor std(const Tensor & self, bool unbiased=true);
static inline Tensor std(const Tensor & self, IntArrayRef dim, bool unbiased=true, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> std_mean(const Tensor & self, bool unbiased=true);
static inline std::tuple<Tensor,Tensor> std_mean(const Tensor & self, IntArrayRef dim, bool unbiased=true, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> std_mean(const Tensor & self, DimnameList dim, bool unbiased=true, bool keepdim=false);
static inline Tensor & std_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool unbiased=true, bool keepdim=false);
static inline Tensor std(const Tensor & self, DimnameList dim, bool unbiased=true, bool keepdim=false);
static inline Tensor & std_out(Tensor & out, const Tensor & self, DimnameList dim, bool unbiased=true, bool keepdim=false);
static inline Tensor prod(const Tensor & self, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor prod(const Tensor & self, int64_t dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & prod_out(Tensor & out, const Tensor & self, int64_t dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor prod(const Tensor & self, Dimname dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
static inline Tensor & prod_out(Tensor & out, const Tensor & self, Dimname dim, bool keepdim=false, c10::optional<ScalarType> dtype=c10::nullopt);
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 & out, const Tensor & self);
static inline Tensor tanh(const Tensor & self);
static inline Tensor & tanh_(Tensor & self);
static inline Tensor & tanh_out(Tensor & out, const Tensor & self);
static inline Tensor tensordot(const Tensor & self, const Tensor & other, IntArrayRef dims_self, IntArrayRef 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 & out, 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 transpose(const Tensor & self, Dimname dim0, Dimname dim1);
static inline Tensor _mkldnn_transpose(const Tensor & self, int64_t dim0, int64_t dim1);
static inline Tensor & _mkldnn_transpose_(Tensor & self, int64_t dim0, int64_t dim1);
static inline Tensor one_hot(const Tensor & self, int64_t num_classes=-1);
static inline Tensor flip(const Tensor & self, IntArrayRef dims);
static inline Tensor roll(const Tensor & self, IntArrayRef shifts, IntArrayRef dims={});
static inline Tensor rot90(const Tensor & self, int64_t k=1, IntArrayRef dims={0,1});
static inline Tensor trapz(const Tensor & y, const Tensor & x, int64_t dim=-1);
static inline Tensor trapz(const Tensor & y, double dx=1, int64_t dim=-1);
static inline Tensor _trilinear(const Tensor & i1, const Tensor & i2, const Tensor & i3, IntArrayRef expand1, IntArrayRef expand2, IntArrayRef expand3, IntArrayRef 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=at::Reduction::Mean);
static inline Tensor true_divide(const Tensor & self, const Tensor & other);
static inline Tensor & true_divide_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor true_divide(const Tensor & self, Scalar other);
static inline Tensor trunc(const Tensor & self);
static inline Tensor & trunc_(Tensor & self);
static inline Tensor & trunc_out(Tensor & out, const Tensor & self);
static inline bool _has_compatible_shallow_copy_type(const Tensor & self, const Tensor & from);
static inline std::tuple<Tensor,Tensor> _unique(const Tensor & self, bool sorted=true, bool return_inverse=false);
static inline std::tuple<Tensor,Tensor,Tensor> unique_dim(const Tensor & self, int64_t dim, bool sorted=true, bool return_inverse=false, bool return_counts=false);
static inline std::tuple<Tensor,Tensor,Tensor> unique_consecutive(const Tensor & self, bool return_inverse=false, bool return_counts=false, c10::optional<int64_t> dim=c10::nullopt);
static inline std::tuple<Tensor,Tensor,Tensor> unique_dim_consecutive(const Tensor & self, int64_t dim, bool return_inverse=false, bool return_counts=false);
static inline std::tuple<Tensor,Tensor,Tensor> _unique2(const Tensor & self, bool sorted=true, bool return_inverse=false, bool return_counts=false);
static inline Tensor _unsafe_view(const Tensor & self, IntArrayRef 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, IntArrayRef dim, bool unbiased=true, bool keepdim=false);
static inline Tensor & var_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool unbiased=true, bool keepdim=false);
static inline Tensor var(const Tensor & self, DimnameList dim, bool unbiased=true, bool keepdim=false);
static inline Tensor & var_out(Tensor & out, const Tensor & self, DimnameList dim, bool unbiased=true, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> var_mean(const Tensor & self, bool unbiased=true);
static inline std::tuple<Tensor,Tensor> var_mean(const Tensor & self, IntArrayRef dim, bool unbiased=true, bool keepdim=false);
static inline std::tuple<Tensor,Tensor> var_mean(const Tensor & self, DimnameList dim, bool unbiased=true, bool keepdim=false);
static inline Tensor where(const Tensor & condition, const Tensor & self, const Tensor & other);
static inline std::vector<Tensor> where(const Tensor & condition);
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(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options={});
static inline Tensor zeros(IntArrayRef size, const TensorOptions & options={});
static inline Tensor & zeros_out(Tensor & out, IntArrayRef size);
static inline Tensor zeros_like(const Tensor & self, const TensorOptions & options={}, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor _standard_gamma_grad(const Tensor & self, const Tensor & output);
static inline Tensor _standard_gamma(const Tensor & self, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor _dirichlet_grad(const Tensor & x, const Tensor & alpha, const Tensor & total);
static inline Tensor _sample_dirichlet(const Tensor & self, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor poisson(const Tensor & self, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor binomial(const Tensor & count, const Tensor & prob, c10::optional<Generator> generator=c10::nullopt);
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, IntArrayRef dim);
static inline Tensor _sparse_sum(const Tensor & self, IntArrayRef dim, ScalarType dtype);
static inline Tensor _sparse_sum_backward(const Tensor & grad, const Tensor & self, IntArrayRef dim);
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, ScalarType dtype);
static inline Tensor norm(const Tensor & self, Scalar p=2);
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim, ScalarType dtype);
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim=false);
static inline Tensor & norm_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim, ScalarType dtype);
static inline Tensor & norm_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim=false);
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, DimnameList dim, bool keepdim, ScalarType dtype);
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, DimnameList dim, bool keepdim=false);
static inline Tensor & norm_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, DimnameList dim, bool keepdim, ScalarType dtype);
static inline Tensor & norm_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, DimnameList dim, bool keepdim=false);
static inline Tensor frobenius_norm(const Tensor & self);
static inline Tensor frobenius_norm(const Tensor & self, IntArrayRef dim, bool keepdim=false);
static inline Tensor & frobenius_norm_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim=false);
static inline Tensor nuclear_norm(const Tensor & self, bool keepdim=false);
static inline Tensor & nuclear_norm_out(Tensor & out, const Tensor & self, bool keepdim=false);
static inline Tensor nuclear_norm(const Tensor & self, IntArrayRef dim, bool keepdim=false);
static inline Tensor & nuclear_norm_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim=false);
static inline Tensor clone(const Tensor & self, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor & resize_as_(Tensor & self, const Tensor & the_template, c10::optional<MemoryFormat> memory_format=c10::nullopt);
static inline Tensor & pow_out(Tensor & out, const Tensor & self, Scalar exponent);
static inline Tensor pow(const Tensor & self, Scalar exponent);
static inline Tensor & zero_(Tensor & self);
static inline Tensor & sub_out(Tensor & out, 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 _sparse_addmm(const Tensor & self, const Tensor & sparse, const Tensor & dense, Scalar beta=1, Scalar alpha=1);
static inline Tensor & addmm_out(Tensor & out, 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(IntArrayRef 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, IntArrayRef size, const TensorOptions & options={});
static inline Tensor _sparse_coo_tensor_unsafe(const Tensor & indices, const Tensor & values, IntArrayRef size, const TensorOptions & options={});
static inline Tensor _sparse_coo_tensor_with_dims(int64_t sparse_dim, int64_t dense_dim, IntArrayRef size, const TensorOptions & options);
static inline Tensor _sparse_coo_tensor_with_dims_and_tensors(int64_t sparse_dim, int64_t dense_dim, IntArrayRef size, const Tensor & indices, const Tensor & values, const TensorOptions & options);
static inline Tensor to_dense_backward(const Tensor & grad, const Tensor & input);
static inline Tensor & hspmm_out(Tensor & out, 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 std::vector<Tensor> unbind(const Tensor & self, int64_t dim=0);
static inline std::vector<Tensor> unbind(const Tensor & self, Dimname dim);
static inline Tensor mkldnn_reorder_conv2d_weight(const Tensor & self, IntArrayRef padding=0, IntArrayRef stride=1, IntArrayRef dilation=1, int64_t groups=1);
static inline Tensor to_mkldnn_backward(const Tensor & grad, const Tensor & input);
static inline Tensor quantize_per_tensor(const Tensor & self, double scale, int64_t zero_point, ScalarType dtype);
static inline std::vector<Tensor> quantize_per_tensor(TensorList tensors, const Tensor & scales, const Tensor & zero_points, ScalarType dtype);
static inline Tensor quantize_per_channel(const Tensor & self, const Tensor & scales, const Tensor & zero_points, int64_t axis, ScalarType dtype);
static inline Tensor dequantize(const Tensor & self);
static inline std::vector<Tensor> dequantize(TensorList tensors);
static inline double q_scale(const Tensor & self);
static inline int64_t q_zero_point(const Tensor & self);
static inline Tensor q_per_channel_scales(const Tensor & self);
static inline Tensor q_per_channel_zero_points(const Tensor & self);
static inline int64_t q_per_channel_axis(const Tensor & self);
static inline Tensor int_repr(const Tensor & self);
static inline Tensor _make_per_tensor_quantized_tensor(const Tensor & self, double scale, int64_t zero_point);
static inline Tensor _make_per_channel_quantized_tensor(const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis);
static inline Tensor fake_quantize_per_tensor_affine(const Tensor & self, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max);
static inline Tensor fake_quantize_per_tensor_affine_backward(const Tensor & grad, const Tensor & self, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max);
static inline Tensor fake_quantize_per_channel_affine(const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max);
static inline Tensor fake_quantize_per_channel_affine_backward(const Tensor & grad, const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max);
static inline std::tuple<double,int64_t> _choose_qparams_per_tensor(const Tensor & self, bool reduce_range=false);
static inline std::vector<Tensor> meshgrid(TensorList tensors);
static inline Tensor cartesian_prod(TensorList tensors);
static inline Tensor combinations(const Tensor & self, int64_t r=2, bool with_replacement=false);
static inline ScalarType result_type(const Tensor & tensor, const Tensor & other);
static inline ScalarType result_type(const Tensor & tensor, Scalar other);
static inline ScalarType result_type(Scalar scalar, const Tensor & tensor);
static inline ScalarType result_type(Scalar scalar1, Scalar scalar2);
static inline bool can_cast(ScalarType from, ScalarType to);
static inline ScalarType promote_types(ScalarType type1, ScalarType type2);
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,Tensor,Tensor,Tensor> _thnn_differentiable_lstm_cell_backward(const Tensor & grad_hy, const Tensor & grad_cy, const Tensor & input_gates, const Tensor & hidden_gates, const Tensor & input_bias, const Tensor & hidden_bias, const Tensor & cx, const Tensor & cy);
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,Tensor,Tensor> _thnn_differentiable_gru_cell_backward(const Tensor & grad_hy, 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> 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,Tensor> quantized_lstm(const Tensor & input, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first, c10::optional<ScalarType> dtype=c10::nullopt, bool use_dynamic=false);
static inline std::tuple<Tensor,Tensor,Tensor> quantized_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, c10::optional<ScalarType> dtype=c10::nullopt, bool use_dynamic=false);
static inline std::tuple<Tensor,Tensor> quantized_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> quantized_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> quantized_lstm_cell(const Tensor & input, TensorList hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih, const Tensor & b_hh, const Tensor & packed_ih, const Tensor & packed_hh, const Tensor & col_offsets_ih, const Tensor & col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh);
static inline Tensor quantized_gru_cell(const Tensor & input, const Tensor & hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih, const Tensor & b_hh, const Tensor & packed_ih, const Tensor & packed_hh, const Tensor & col_offsets_ih, const Tensor & col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh);
static inline Tensor quantized_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, const Tensor & packed_ih, const Tensor & packed_hh, const Tensor & col_offsets_ih, const Tensor & col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh);
static inline Tensor quantized_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, const Tensor & packed_ih, const Tensor & packed_hh, const Tensor & col_offsets_ih, const Tensor & col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_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, IntArrayRef 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 masked_fill(const Tensor & self, const Tensor & mask, Scalar value);
static inline Tensor masked_fill(const Tensor & self, const Tensor & mask, const Tensor & value);
static inline Tensor masked_scatter(const Tensor & self, const Tensor & mask, const Tensor & source);
static inline Tensor index_add(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & source);
static inline Tensor index_add(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & source);
static inline Tensor index_fill(const Tensor & self, int64_t dim, const Tensor & index, Scalar value);
static inline Tensor index_fill(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & value);
static inline Tensor index_fill(const Tensor & self, Dimname dim, const Tensor & index, Scalar value);
static inline Tensor index_fill(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & value);
static inline Tensor scatter(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & src);
static inline Tensor scatter(const Tensor & self, int64_t dim, const Tensor & index, Scalar value);
static inline Tensor scatter(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & src);
static inline Tensor scatter(const Tensor & self, Dimname dim, const Tensor & index, Scalar value);
static inline Tensor scatter_add(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & src);
static inline Tensor scatter_add(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & src);
static inline Tensor & bitwise_and_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor & bitwise_and_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor bitwise_and(const Tensor & self, Scalar other);
static inline Tensor bitwise_and(const Tensor & self, const Tensor & other);
static inline Tensor __and__(const Tensor & self, Scalar other);
static inline Tensor __and__(const Tensor & self, const Tensor & other);
static inline Tensor & bitwise_or_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor & bitwise_or_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor bitwise_or(const Tensor & self, Scalar other);
static inline Tensor bitwise_or(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 & bitwise_xor_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor & bitwise_xor_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor bitwise_xor(const Tensor & self, Scalar other);
static inline Tensor bitwise_xor(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 & out, 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 & out, const Tensor & self, int64_t diagonal=0);
static inline Tensor diag(const Tensor & self, int64_t diagonal=0);
static inline Tensor & cross_out(Tensor & out, const Tensor & self, const Tensor & other, c10::optional<int64_t> dim=c10::nullopt);
static inline Tensor cross(const Tensor & self, const Tensor & other, c10::optional<int64_t> dim=c10::nullopt);
static inline Tensor & triu_out(Tensor & out, const Tensor & self, int64_t diagonal=0);
static inline Tensor triu(const Tensor & self, int64_t diagonal=0);
static inline Tensor & tril_out(Tensor & out, const Tensor & self, int64_t diagonal=0);
static inline Tensor tril(const Tensor & self, int64_t diagonal=0);
static inline Tensor tril_indices(int64_t row, int64_t col, int64_t offset=0, const TensorOptions & options=at::kLong);
static inline Tensor triu_indices(int64_t row, int64_t col, int64_t offset=0, const TensorOptions & options=at::kLong);
static inline Tensor trace(const Tensor & self);
static inline Tensor & ne_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor ne(const Tensor & self, Scalar other);
static inline Tensor & ne_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor ne(const Tensor & self, const Tensor & other);
static inline Tensor & eq_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor eq(const Tensor & self, Scalar other);
static inline Tensor & eq_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor eq(const Tensor & self, const Tensor & other);
static inline Tensor & ge_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor ge(const Tensor & self, Scalar other);
static inline Tensor & ge_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor ge(const Tensor & self, const Tensor & other);
static inline Tensor & le_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor le(const Tensor & self, Scalar other);
static inline Tensor & le_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor le(const Tensor & self, const Tensor & other);
static inline Tensor & gt_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor gt(const Tensor & self, Scalar other);
static inline Tensor & gt_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor gt(const Tensor & self, const Tensor & other);
static inline Tensor & lt_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor lt(const Tensor & self, Scalar other);
static inline Tensor & lt_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor lt(const Tensor & self, const Tensor & other);
static inline Tensor & take_out(Tensor & out, const Tensor & self, const Tensor & index);
static inline Tensor take(const Tensor & self, const Tensor & index);
static inline Tensor & index_select_out(Tensor & out, 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 & index_select_out(Tensor & out, const Tensor & self, Dimname dim, const Tensor & index);
static inline Tensor index_select(const Tensor & self, Dimname dim, const Tensor & index);
static inline Tensor & masked_select_out(Tensor & out, const Tensor & self, const Tensor & mask);
static inline Tensor masked_select(const Tensor & self, const Tensor & mask);
static inline Tensor & nonzero_out(Tensor & out, const Tensor & self);
static inline Tensor nonzero(const Tensor & self);
static inline std::vector<Tensor> nonzero_numpy(const Tensor & self);
static inline Tensor & gather_out(Tensor & out, const Tensor & self, int64_t dim, const Tensor & index, bool sparse_grad=false);
static inline Tensor gather(const Tensor & self, int64_t dim, const Tensor & index, bool sparse_grad=false);
static inline Tensor & gather_out(Tensor & out, const Tensor & self, Dimname dim, const Tensor & index, bool sparse_grad=false);
static inline Tensor gather(const Tensor & self, Dimname dim, const Tensor & index, bool sparse_grad=false);
static inline Tensor _gather_sparse_backward(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & grad);
static inline Tensor & addcmul_out(Tensor & out, 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 & out, 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 &> lstsq_out(Tensor & X, Tensor & qr, const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor,Tensor> lstsq(const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor &,Tensor &> triangular_solve_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> triangular_solve(const Tensor & self, const Tensor & A, bool upper=true, bool transpose=false, bool unitriangular=false);
static inline std::tuple<Tensor,Tensor> _triangular_solve_helper(const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular);
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> _symeig_helper(const Tensor & self, bool eigenvectors, bool upper);
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 std::tuple<Tensor,Tensor,Tensor> _svd_helper(const Tensor & self, bool some, bool compute_uv);
static inline Tensor & cholesky_out(Tensor & out, 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 & cholesky_solve_out(Tensor & out, const Tensor & self, const Tensor & input2, bool upper=false);
static inline Tensor cholesky_solve(const Tensor & self, const Tensor & input2, bool upper=false);
static inline Tensor _cholesky_solve_helper(const Tensor & self, const Tensor & A, bool upper);
static inline std::tuple<Tensor,Tensor> solve(const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor &,Tensor &> solve_out(Tensor & solution, Tensor & lu, const Tensor & self, const Tensor & A);
static inline std::tuple<Tensor,Tensor> _solve_helper(const Tensor & self, const Tensor & A);
static inline Tensor & cholesky_inverse_out(Tensor & out, const Tensor & self, bool upper=false);
static inline Tensor cholesky_inverse(const Tensor & self, bool upper=false);
static inline std::tuple<Tensor &,Tensor &> qr_out(Tensor & Q, Tensor & R, const Tensor & self, bool some=true);
static inline std::tuple<Tensor,Tensor> qr(const Tensor & self, bool some=true);
static inline std::tuple<Tensor,Tensor> _qr_helper(const Tensor & self, bool some);
static inline std::tuple<Tensor &,Tensor &> geqrf_out(Tensor & a, Tensor & tau, const Tensor & self);
static inline std::tuple<Tensor,Tensor> geqrf(const Tensor & self);
static inline Tensor & orgqr_out(Tensor & out, const Tensor & self, const Tensor & input2);
static inline Tensor orgqr(const Tensor & self, const Tensor & input2);
static inline Tensor & ormqr_out(Tensor & out, 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,Tensor> _lu_with_info(const Tensor & self, bool pivot=true, bool check_errors=true);
static inline Tensor & lu_solve_out(Tensor & out, const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots);
static inline Tensor lu_solve(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots);
static inline Tensor _lu_solve_helper(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots);
static inline Tensor & multinomial_out(Tensor & out, const Tensor & self, int64_t num_samples, bool replacement=false, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor multinomial(const Tensor & self, int64_t num_samples, bool replacement=false, c10::optional<Generator> generator=c10::nullopt);
static inline std::tuple<Tensor,Tensor> _multinomial_alias_setup(const Tensor & probs);
static inline Tensor _multinomial_alias_draw(const Tensor & J, const Tensor & q, int64_t num_samples, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor & lgamma_out(Tensor & out, const Tensor & self);
static inline Tensor lgamma(const Tensor & self);
static inline Tensor & digamma_out(Tensor & out, const Tensor & self);
static inline Tensor digamma(const Tensor & self);
static inline Tensor & polygamma_out(Tensor & out, int64_t n, const Tensor & self);
static inline Tensor polygamma(int64_t n, const Tensor & self);
static inline Tensor erfinv(const Tensor & self);
static inline Tensor & erfinv_out(Tensor & out, const Tensor & self);
static inline Tensor sign(const Tensor & self);
static inline Tensor & sign_out(Tensor & out, const Tensor & self);
static inline Tensor dist(const Tensor & self, const Tensor & other, Scalar p=2);
static inline Tensor & atan2_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor atan2(const Tensor & self, const Tensor & other);
static inline Tensor & lerp_out(Tensor & out, const Tensor & self, const Tensor & end, Scalar weight);
static inline Tensor & lerp_out(Tensor & out, const Tensor & self, const Tensor & end, const Tensor & weight);
static inline Tensor lerp(const Tensor & self, const Tensor & end, Scalar weight);
static inline Tensor lerp(const Tensor & self, const Tensor & end, const Tensor & weight);
static inline Tensor & histc_out(Tensor & out, 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 & fmod_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor fmod(const Tensor & self, Scalar other);
static inline Tensor & fmod_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor fmod(const Tensor & self, const Tensor & other);
static inline Tensor & remainder_out(Tensor & out, const Tensor & self, Scalar other);
static inline Tensor remainder(const Tensor & self, Scalar other);
static inline Tensor & remainder_out(Tensor & out, const Tensor & self, const Tensor & other);
static inline Tensor remainder(const Tensor & self, const Tensor & other);
static inline Tensor & min_out(Tensor & out, 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 & out, 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 &> sort_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim, bool descending=false);
static inline std::tuple<Tensor,Tensor> sort(const Tensor & self, Dimname dim, bool descending=false);
static inline Tensor argsort(const Tensor & self, int64_t dim=-1, bool descending=false);
static inline Tensor argsort(const Tensor & self, Dimname dim, 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 & out, 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 & out, const Tensor & self, const Tensor & exponent);
static inline Tensor pow(const Tensor & self, const Tensor & exponent);
static inline Tensor & pow_out(Tensor & out, Scalar self, const Tensor & exponent);
static inline Tensor pow(Scalar self, const Tensor & exponent);
static inline Tensor & normal_out(Tensor & out, const Tensor & mean, double std=1, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor normal(const Tensor & mean, double std=1, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor & normal_out(Tensor & out, double mean, const Tensor & std, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor normal(double mean, const Tensor & std, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor & normal_out(Tensor & out, const Tensor & mean, const Tensor & std, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor normal(const Tensor & mean, const Tensor & std, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor normal(double mean, double std, IntArrayRef size, c10::optional<Generator> generator=c10::nullopt, const TensorOptions & options={});
static inline Tensor & normal_out(Tensor & out, double mean, double std, IntArrayRef size, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor alias(const Tensor & self);
static inline Tensor _addr(const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _addr_(Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _addr_out(Tensor & out, const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta=1, Scalar alpha=1);
static inline Tensor & _index_copy_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & source);
static inline Tensor _cumsum(const Tensor & self, int64_t dim);
static inline Tensor & _cumsum_out(Tensor & out, const Tensor & self, int64_t dim);
static inline Tensor _cumprod(const Tensor & self, int64_t dim);
static inline Tensor & _cumprod_out(Tensor & out, const Tensor & self, int64_t dim);
static inline Tensor _var(const Tensor & self, bool unbiased=true);
static inline Tensor _std(const Tensor & self, bool unbiased=true);
static inline void _amp_non_finite_check_and_unscale_(Tensor & self, Tensor & found_inf, const Tensor & inv_scale);
static inline Tensor _amp_update_scale(Tensor & growth_tracker, const Tensor & current_scale, const Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval);
static inline Tensor _cat(TensorList tensors, int64_t dim=0);
static inline Tensor & _cat_out(Tensor & out, TensorList tensors, int64_t dim=0);
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 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_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 bucketize(const Tensor & self, const Tensor & boundaries, bool out_int32=false, bool right=false);
static inline Tensor & bucketize_out(Tensor & out, const Tensor & self, const Tensor & boundaries, bool out_int32=false, bool right=false);
static inline Tensor bucketize(Scalar self, const Tensor & boundaries, bool out_int32=false, bool right=false);
static inline Tensor searchsorted(const Tensor & sorted_sequence, const Tensor & self, bool out_int32=false, bool right=false);
static inline Tensor & searchsorted_out(Tensor & out, const Tensor & sorted_sequence, const Tensor & self, bool out_int32=false, bool right=false);
static inline Tensor searchsorted(const Tensor & sorted_sequence, Scalar self, bool out_int32=false, bool right=false);
static inline Tensor & mse_loss_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction=at::Reduction::Mean);
static inline Tensor mse_loss(const Tensor & self, const Tensor & target, int64_t reduction=at::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 & out, const Tensor & self, const Tensor & target, int64_t reduction=at::Reduction::Mean);
static inline Tensor l1_loss(const Tensor & self, const Tensor & target, int64_t reduction=at::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 & out, const Tensor & self, const Tensor & target, Scalar p=1, Scalar margin=1, const Tensor & weight={}, int64_t reduction=at::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=at::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=at::Reduction::Mean);
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=at::Reduction::Mean);
static inline Tensor & multilabel_margin_loss_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction=at::Reduction::Mean);
static inline Tensor multilabel_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction=at::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 & out, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=at::Reduction::Mean, int64_t ignore_index=-100);
static inline Tensor nll_loss(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=at::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 & out, const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=at::Reduction::Mean, int64_t ignore_index=-100);
static inline Tensor nll_loss2d(const Tensor & self, const Tensor & target, const Tensor & weight={}, int64_t reduction=at::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 & out, const Tensor & self, const Tensor & target, int64_t reduction=at::Reduction::Mean);
static inline Tensor smooth_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction=at::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 & out, const Tensor & self, const Tensor & target, int64_t reduction=at::Reduction::Mean);
static inline Tensor soft_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction=at::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 & out, 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 & out, 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 & hardsigmoid_out(Tensor & out, const Tensor & self);
static inline Tensor hardsigmoid(const Tensor & self);
static inline Tensor & hardsigmoid_(Tensor & self);
static inline Tensor hardsigmoid_backward(const Tensor & grad_output, const Tensor & self);
static inline Tensor & hardtanh_out(Tensor & out, 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 & hardswish_out(Tensor & out, const Tensor & self);
static inline Tensor hardswish(const Tensor & self);
static inline Tensor & hardswish_(Tensor & self);
static inline Tensor hardswish_backward(const Tensor & grad_output, const Tensor & self);
static inline Tensor & leaky_relu_out(Tensor & out, 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(const Tensor & grad_output, const Tensor & self, Scalar negative_slope, bool self_is_result);
static inline Tensor & leaky_relu_(Tensor & self, Scalar negative_slope=0.01);
static inline Tensor & log_sigmoid_out(Tensor & out, 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 & out, const Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor rrelu_with_noise(const Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor rrelu_with_noise_backward(const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, bool self_is_result);
static inline Tensor & rrelu_with_noise_(Tensor & self, const Tensor & noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=false, c10::optional<Generator> generator=c10::nullopt);
static inline Tensor & softplus_out(Tensor & out, 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 & out, 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 & out, const Tensor & self, IntArrayRef output_size);
static inline Tensor adaptive_avg_pool2d(const Tensor & self, IntArrayRef output_size);
static inline Tensor mkldnn_adaptive_avg_pool2d(const Tensor & self, IntArrayRef output_size);
static inline Tensor _adaptive_avg_pool2d(const Tensor & self, IntArrayRef output_size);
static inline Tensor _adaptive_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self);
static inline Tensor & adaptive_avg_pool3d_out(Tensor & out, const Tensor & self, IntArrayRef output_size);
static inline Tensor adaptive_avg_pool3d(const Tensor & self, IntArrayRef 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 & out, Tensor & indices, const Tensor & self, IntArrayRef output_size);
static inline std::tuple<Tensor,Tensor> adaptive_max_pool2d(const Tensor & self, IntArrayRef 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 & out, Tensor & indices, const Tensor & self, IntArrayRef output_size);
static inline std::tuple<Tensor,Tensor> adaptive_max_pool3d(const Tensor & self, IntArrayRef 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 & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, bool ceil_mode=false, bool count_include_pad=true, c10::optional<int64_t> divisor_override=c10::nullopt);
static inline Tensor avg_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, bool ceil_mode=false, bool count_include_pad=true, c10::optional<int64_t> divisor_override=c10::nullopt);
static inline Tensor & avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
static inline Tensor avg_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
static inline Tensor & avg_pool3d_out(Tensor & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, bool ceil_mode=false, bool count_include_pad=true, c10::optional<int64_t> divisor_override=c10::nullopt);
static inline Tensor avg_pool3d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, bool ceil_mode=false, bool count_include_pad=true, c10::optional<int64_t> divisor_override=c10::nullopt);
static inline Tensor & avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
static inline Tensor avg_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
static inline std::tuple<Tensor &,Tensor &> fractional_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples);
static inline std::tuple<Tensor,Tensor> fractional_max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples);
static inline Tensor & fractional_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices);
static inline Tensor fractional_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> fractional_max_pool3d_out(Tensor & output, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples);
static inline std::tuple<Tensor,Tensor> fractional_max_pool3d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples);
static inline Tensor & fractional_max_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices);
static inline Tensor fractional_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> max_pool2d_with_indices_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef dilation=1, bool ceil_mode=false);
static inline std::tuple<Tensor,Tensor> max_pool2d_with_indices(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef 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, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor max_pool2d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices);
static inline std::tuple<Tensor &,Tensor &> max_pool3d_with_indices_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef dilation=1, bool ceil_mode=false);
static inline std::tuple<Tensor,Tensor> max_pool3d_with_indices(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride={}, IntArrayRef padding=0, IntArrayRef 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, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor max_pool3d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices);
static inline Tensor & max_unpool2d_out(Tensor & out, const Tensor & self, const Tensor & indices, IntArrayRef output_size);
static inline Tensor max_unpool2d(const Tensor & self, const Tensor & indices, IntArrayRef output_size);
static inline Tensor & max_unpool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size);
static inline Tensor max_unpool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size);
static inline Tensor & max_unpool3d_out(Tensor & out, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding);
static inline Tensor max_unpool3d(const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding);
static inline Tensor & max_unpool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding);
static inline Tensor max_unpool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding);
static inline Tensor & reflection_pad1d_out(Tensor & out, const Tensor & self, IntArrayRef padding);
static inline Tensor reflection_pad1d(const Tensor & self, IntArrayRef padding);
static inline Tensor & reflection_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor reflection_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor & reflection_pad2d_out(Tensor & out, const Tensor & self, IntArrayRef padding);
static inline Tensor reflection_pad2d(const Tensor & self, IntArrayRef padding);
static inline Tensor & reflection_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor reflection_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor & replication_pad1d_out(Tensor & out, const Tensor & self, IntArrayRef padding);
static inline Tensor replication_pad1d(const Tensor & self, IntArrayRef padding);
static inline Tensor & replication_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor replication_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor & replication_pad2d_out(Tensor & out, const Tensor & self, IntArrayRef padding);
static inline Tensor replication_pad2d(const Tensor & self, IntArrayRef padding);
static inline Tensor & replication_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor replication_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor & replication_pad3d_out(Tensor & out, const Tensor & self, IntArrayRef padding);
static inline Tensor replication_pad3d(const Tensor & self, IntArrayRef padding);
static inline Tensor & replication_pad3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor replication_pad3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding);
static inline Tensor & upsample_linear1d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales=c10::nullopt);
static inline Tensor upsample_linear1d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales=c10::nullopt);
static inline Tensor & upsample_linear1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales=c10::nullopt);
static inline Tensor upsample_linear1d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales=c10::nullopt);
static inline Tensor & upsample_bilinear2d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_bilinear2d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_bilinear2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_bilinear2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_bicubic2d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_bicubic2d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_bicubic2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_bicubic2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_trilinear3d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_trilinear3d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_trilinear3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_trilinear3d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_nearest1d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales=c10::nullopt);
static inline Tensor upsample_nearest1d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales=c10::nullopt);
static inline Tensor & upsample_nearest1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales=c10::nullopt);
static inline Tensor upsample_nearest1d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales=c10::nullopt);
static inline Tensor & upsample_nearest2d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_nearest2d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_nearest2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_nearest2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_nearest3d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_nearest3d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor & upsample_nearest3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
static inline Tensor upsample_nearest3d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
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 & slow_conv_transpose2d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef output_padding=0, IntArrayRef dilation=1);
static inline Tensor slow_conv_transpose2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef output_padding=0, IntArrayRef dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> slow_conv_transpose2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & columns, const Tensor & ones);
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv_transpose2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask);
static inline Tensor & slow_conv_transpose3d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef output_padding=0, IntArrayRef dilation=1);
static inline Tensor slow_conv_transpose3d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef output_padding=0, IntArrayRef dilation=1);
static inline std::tuple<Tensor &,Tensor &,Tensor &> slow_conv_transpose3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & finput, const Tensor & fgrad_input);
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv_transpose3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
static inline Tensor & thnn_conv2d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0);
static inline Tensor thnn_conv2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef 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, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding);
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_forward(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef 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, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef 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, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
static inline Tensor & thnn_conv_depthwise2d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef dilation=1);
static inline Tensor thnn_conv_depthwise2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef dilation=1);
static inline Tensor & thnn_conv_depthwise2d_forward_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation);
static inline Tensor thnn_conv_depthwise2d_forward(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef 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, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation);
static inline std::tuple<Tensor,Tensor> thnn_conv_depthwise2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, std::array<bool,2> output_mask);
static inline Tensor & slow_conv3d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0);
static inline Tensor slow_conv3d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0);
static inline std::tuple<Tensor &,Tensor &,Tensor &> slow_conv3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding);
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv3d_forward(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding);
static inline std::tuple<Tensor &,Tensor &,Tensor &> slow_conv3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input);
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask);
static inline Tensor slow_conv_dilated2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef dilation=1);
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv_dilated2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, std::array<bool,3> output_mask);
static inline Tensor slow_conv_dilated3d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias={}, IntArrayRef stride=1, IntArrayRef padding=0, IntArrayRef dilation=1);
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv_dilated3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, std::array<bool,3> output_mask);
static inline Tensor & col2im_out(Tensor & out, const Tensor & self, IntArrayRef output_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
static inline Tensor col2im(const Tensor & self, IntArrayRef output_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
static inline Tensor & col2im_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
static inline Tensor col2im_backward(const Tensor & grad_output, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
static inline Tensor & im2col_out(Tensor & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
static inline Tensor im2col(const Tensor & self, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
static inline Tensor & im2col_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef input_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
static inline Tensor im2col_backward(const Tensor & grad_output, IntArrayRef input_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride);
static inline Tensor isfinite(const Tensor & self);
static inline Tensor isinf(const Tensor & self);
static inline Tensor _test_serialization_subcmul(const Tensor & self, const Tensor & other, Scalar alpha=1);

inline Tensor from_blob(
    void* data,
    IntArrayRef sizes,
    IntArrayRef strides,
    const std::function<void(void*)>& deleter,
    const TensorOptions& options = {}) {
  AutoNonVariableTypeMode guard;
  auto device = globalContext().getDeviceFromPtr(data, options.device().type());
  if (options.device().has_index()) {
    TORCH_CHECK(
        options.device() == device,
        "Specified device ", options.device(),
        " does not match device of data ", device);
  }
  auto storage = Storage(
      options.dtype(),
      detail::computeStorageSize(sizes, strides),
      InefficientStdFunctionContext::makeDataPtr(
          data, deleter, device),
      /*allocator=*/nullptr,
      /*resizable=*/false);
  return empty({0}, options).set_(storage, 0, sizes, strides);
}

inline Tensor from_blob(
    void* data,
    IntArrayRef sizes,
    const std::function<void(void*)>& deleter,
    const TensorOptions& options = {}) {
  return from_blob(data, sizes, detail::defaultStrides(sizes), deleter, options);
}

inline Tensor from_blob(
    void* data,
    IntArrayRef sizes,
    IntArrayRef strides,
    const TensorOptions& options = {}) {
  AutoNonVariableTypeMode guard;
  auto device = globalContext().getDeviceFromPtr(data, options.device().type());
  if (options.device().has_index()) {
    TORCH_CHECK(
        options.device() == device,
        "Specified device ", options.device(),
        " does not match device of data ", device);
  }
  auto storage = Storage(
      options.dtype(),
      detail::computeStorageSize(sizes, strides),
      DataPtr(data, nullptr, [](void*) {}, device),
      /*allocator=*/nullptr,
      /*resizable=*/false);
  return empty({0}, options).set_(storage, 0, sizes, strides);
}

inline Tensor from_blob(
    void* data,
    IntArrayRef sizes,
    const TensorOptions& options = {}) {
  return from_blob(data, sizes, detail::defaultStrides(sizes), options);
}

inline int64_t numel(const Tensor& tensor) {
  return tensor.numel();
}

// function definitions are all static inline because
// they are one-line statically dispatched functions that
// invoke the actual dynamic dispatch on the correct argument

// aten::_cast_Byte(Tensor self, bool non_blocking=False) -> Tensor
static inline Tensor _cast_Byte(const Tensor & self, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cast_Byte(self, non_blocking);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cast_Byte", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, non_blocking);
#endif
}

// aten::_cast_Char(Tensor self, bool non_blocking=False) -> Tensor
static inline Tensor _cast_Char(const Tensor & self, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cast_Char(self, non_blocking);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cast_Char", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, non_blocking);
#endif
}

// aten::_cast_Double(Tensor self, bool non_blocking=False) -> Tensor
static inline Tensor _cast_Double(const Tensor & self, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cast_Double(self, non_blocking);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cast_Double", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, non_blocking);
#endif
}

// aten::_cast_Float(Tensor self, bool non_blocking=False) -> Tensor
static inline Tensor _cast_Float(const Tensor & self, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cast_Float(self, non_blocking);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cast_Float", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, non_blocking);
#endif
}

// aten::_cast_Int(Tensor self, bool non_blocking=False) -> Tensor
static inline Tensor _cast_Int(const Tensor & self, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cast_Int(self, non_blocking);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cast_Int", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, non_blocking);
#endif
}

// aten::_cast_Long(Tensor self, bool non_blocking=False) -> Tensor
static inline Tensor _cast_Long(const Tensor & self, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cast_Long(self, non_blocking);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cast_Long", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, non_blocking);
#endif
}

// aten::_cast_Short(Tensor self, bool non_blocking=False) -> Tensor
static inline Tensor _cast_Short(const Tensor & self, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cast_Short(self, non_blocking);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cast_Short", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, non_blocking);
#endif
}

// aten::_cast_Half(Tensor self, bool non_blocking=False) -> Tensor
static inline Tensor _cast_Half(const Tensor & self, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cast_Half(self, non_blocking);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cast_Half", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, non_blocking);
#endif
}

// aten::align_tensors(Tensor[] tensors) -> Tensor[]
static inline std::vector<Tensor> align_tensors(TensorList tensors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::align_tensors(tensors);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::align_tensors", "");
    return op.callUnboxed<std::vector<Tensor>, TensorList>(tensors);
#endif
}

// aten::_use_cudnn_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank) -> bool
static inline bool _use_cudnn_ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(log_probs, targets);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_use_cudnn_ctc_loss not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_use_cudnn_ctc_loss", "");
    return op.callUnboxed<bool, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, int64_t>(log_probs, targets, input_lengths, target_lengths, blank);
#endif
}

// aten::_cudnn_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank, bool deterministic, bool zero_infinity) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _cudnn_ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank, bool deterministic, bool zero_infinity) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(log_probs, targets);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_cudnn_ctc_loss not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cudnn_ctc_loss", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, int64_t, bool, bool>(log_probs, targets, input_lengths, target_lengths, blank, deterministic, zero_infinity);
#endif
}

// aten::_use_cudnn_rnn_flatten_weight() -> bool
static inline bool _use_cudnn_rnn_flatten_weight() {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_use_cudnn_rnn_flatten_weight();
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_use_cudnn_rnn_flatten_weight", "");
    return op.callUnboxed<bool>();
#endif
}

// aten::_cudnn_rnn_flatten_weight(Tensor[] weight_arr, int weight_stride0, int input_size, int mode, int hidden_size, int num_layers, bool batch_first, bool bidirectional) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(weight_arr);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_cudnn_rnn_flatten_weight not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cudnn_rnn_flatten_weight", "");
    return op.callUnboxed<Tensor, TensorList, int64_t, int64_t, int64_t, int64_t, int64_t, bool, bool>(weight_arr, weight_stride0, input_size, mode, hidden_size, num_layers, batch_first, bidirectional);
#endif
}

// aten::_cudnn_rnn(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, int hidden_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
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, IntArrayRef batch_sizes, const Tensor & dropout_state) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, weight_buf, hx, cx, dropout_state);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_cudnn_rnn not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cudnn_rnn", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor>, const Tensor &, TensorList, int64_t, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, int64_t, bool, double, bool, bool, IntArrayRef, const Tensor &>(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state);
#endif
}

// aten::_cudnn_rnn_backward(Tensor input, Tensor[] weight, int weight_stride0, Tensor weight_buf, Tensor hx, Tensor? cx, Tensor output, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, int mode, int hidden_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state, Tensor reserve, bool[4] output_mask) -> (Tensor, Tensor, Tensor, Tensor[])
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, IntArrayRef batch_sizes, const Tensor & dropout_state, const Tensor & reserve, std::array<bool,4> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, dropout_state, reserve);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_cudnn_rnn_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cudnn_rnn_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,std::vector<Tensor>>, const Tensor &, TensorList, int64_t, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, int64_t, bool, double, bool, bool, IntArrayRef, const Tensor &, const Tensor &, std::array<bool,4>>(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);
#endif
}

// aten::_cudnn_init_dropout_state(float dropout, bool train, int dropout_seed, *, ScalarType dtype, Layout layout, Device device, bool pin_memory=False) -> Tensor
static inline Tensor _cudnn_init_dropout_state(double dropout, bool train, int64_t dropout_seed, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKey _dk = options.computeDispatchKey();
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_cudnn_init_dropout_state not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cudnn_init_dropout_state", "");
    return op.callUnboxed<Tensor, double, bool, int64_t, const TensorOptions &>(dropout, train, dropout_seed, options);
#endif
}

// aten::_debug_has_internal_overlap(Tensor self) -> int
static inline int64_t _debug_has_internal_overlap(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_debug_has_internal_overlap(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_debug_has_internal_overlap", "");
    return op.callUnboxed<int64_t, const Tensor &>(self);
#endif
}

// aten::_fused_dropout(Tensor self, float p, Generator? generator=None) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _fused_dropout(const Tensor & self, double p, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_fused_dropout not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_fused_dropout", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, double, c10::optional<Generator>>(self, p, generator);
#endif
}

// aten::_masked_scale(Tensor self, Tensor mask, float scale) -> Tensor
static inline Tensor _masked_scale(const Tensor & self, const Tensor & mask, double scale) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, mask);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_masked_scale not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_masked_scale", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, double>(self, mask, scale);
#endif
}

// aten::_sobol_engine_draw(Tensor quasi, int n, Tensor sobolstate, int dimension, int num_generated, ScalarType? dtype) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _sobol_engine_draw(const Tensor & quasi, int64_t n, const Tensor & sobolstate, int64_t dimension, int64_t num_generated, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sobol_engine_draw(quasi, n, sobolstate, dimension, num_generated, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sobol_engine_draw", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, const Tensor &, int64_t, int64_t, c10::optional<ScalarType>>(quasi, n, sobolstate, dimension, num_generated, dtype);
#endif
}

// aten::_sobol_engine_ff_(Tensor(a!) self, int n, Tensor sobolstate, int dimension, int num_generated) -> Tensor(a!)
static inline Tensor & _sobol_engine_ff_(Tensor & self, int64_t n, const Tensor & sobolstate, int64_t dimension, int64_t num_generated) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sobol_engine_ff_(self, n, sobolstate, dimension, num_generated);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sobol_engine_ff_", "");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, const Tensor &, int64_t, int64_t>(self, n, sobolstate, dimension, num_generated);
#endif
}

// aten::_sobol_engine_scramble_(Tensor(a!) self, Tensor ltm, int dimension) -> Tensor(a!)
static inline Tensor & _sobol_engine_scramble_(Tensor & self, const Tensor & ltm, int64_t dimension) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sobol_engine_scramble_(self, ltm, dimension);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sobol_engine_scramble_", "");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t>(self, ltm, dimension);
#endif
}

// aten::_sobol_engine_initialize_state_(Tensor(a!) self, int dimension) -> Tensor(a!)
static inline Tensor & _sobol_engine_initialize_state_(Tensor & self, int64_t dimension) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sobol_engine_initialize_state_(self, dimension);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sobol_engine_initialize_state_", "");
    return op.callUnboxed<Tensor &, Tensor &, int64_t>(self, dimension);
#endif
}

// aten::_reshape_from_tensor(Tensor self, Tensor shape) -> Tensor
static inline Tensor _reshape_from_tensor(const Tensor & self, const Tensor & shape) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_reshape_from_tensor(self, shape);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_reshape_from_tensor", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, shape);
#endif
}

// aten::_shape_as_tensor(Tensor self) -> Tensor
static inline Tensor _shape_as_tensor(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_shape_as_tensor(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_shape_as_tensor", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::dropout(Tensor input, float p, bool train) -> Tensor
static inline Tensor dropout(const Tensor & input, double p, bool train) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::dropout(input, p, train);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::dropout", "");
    return op.callUnboxed<Tensor, const Tensor &, double, bool>(input, p, train);
#endif
}

// aten::dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)
static inline Tensor & dropout_(Tensor & self, double p, bool train) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::dropout_(self, p, train);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::dropout_", "");
    return op.callUnboxed<Tensor &, Tensor &, double, bool>(self, p, train);
#endif
}

// aten::feature_dropout(Tensor input, float p, bool train) -> Tensor
static inline Tensor feature_dropout(const Tensor & input, double p, bool train) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::feature_dropout(input, p, train);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::feature_dropout", "");
    return op.callUnboxed<Tensor, const Tensor &, double, bool>(input, p, train);
#endif
}

// aten::feature_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)
static inline Tensor & feature_dropout_(Tensor & self, double p, bool train) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::feature_dropout_(self, p, train);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::feature_dropout_", "");
    return op.callUnboxed<Tensor &, Tensor &, double, bool>(self, p, train);
#endif
}

// aten::alpha_dropout(Tensor input, float p, bool train) -> Tensor
static inline Tensor alpha_dropout(const Tensor & input, double p, bool train) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::alpha_dropout(input, p, train);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::alpha_dropout", "");
    return op.callUnboxed<Tensor, const Tensor &, double, bool>(input, p, train);
#endif
}

// aten::alpha_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)
static inline Tensor & alpha_dropout_(Tensor & self, double p, bool train) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::alpha_dropout_(self, p, train);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::alpha_dropout_", "");
    return op.callUnboxed<Tensor &, Tensor &, double, bool>(self, p, train);
#endif
}

// aten::feature_alpha_dropout(Tensor input, float p, bool train) -> Tensor
static inline Tensor feature_alpha_dropout(const Tensor & input, double p, bool train) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::feature_alpha_dropout(input, p, train);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::feature_alpha_dropout", "");
    return op.callUnboxed<Tensor, const Tensor &, double, bool>(input, p, train);
#endif
}

// aten::feature_alpha_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)
static inline Tensor & feature_alpha_dropout_(Tensor & self, double p, bool train) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::feature_alpha_dropout_(self, p, train);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::feature_alpha_dropout_", "");
    return op.callUnboxed<Tensor &, Tensor &, double, bool>(self, p, train);
#endif
}

// aten::abs(Tensor self) -> Tensor
static inline Tensor abs(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::abs(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::abs", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::abs_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & abs_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::abs_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::abs_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::abs.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & abs_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::abs_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::abs", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::absolute(Tensor self) -> Tensor
static inline Tensor absolute(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::absolute(self);
            break;
        default:
            AT_ERROR("absolute not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::absolute", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::absolute_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & absolute_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::absolute_(self);
            break;
        default:
            AT_ERROR("absolute_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::absolute_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::absolute.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & absolute_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::absolute_out_out(out, self);
            break;
        default:
            AT_ERROR("absolute_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::absolute", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::angle(Tensor self) -> Tensor
static inline Tensor angle(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::angle(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::angle", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::angle.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & angle_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::angle_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::angle", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::real(Tensor self) -> Tensor
static inline Tensor real(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::real(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::real", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::imag(Tensor self) -> Tensor
static inline Tensor imag(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::imag(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::imag", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::copy_real(Tensor self) -> Tensor
static inline Tensor copy_real(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::copy_real(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::copy_real", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::copy_real.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & copy_real_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::copy_real_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::copy_real", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::copy_imag(Tensor self) -> Tensor
static inline Tensor copy_imag(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::copy_imag(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::copy_imag", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::copy_imag.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & copy_imag_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::copy_imag_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::copy_imag", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::conj(Tensor self) -> Tensor
static inline Tensor conj(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conj(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conj", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::conj.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & conj_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conj_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conj", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::acos(Tensor self) -> Tensor
static inline Tensor acos(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::acos(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::acos", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::acos_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & acos_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::acos_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::acos_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::acos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & acos_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::acos_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::acos", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::avg_pool1d(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=0, bool ceil_mode=False, bool count_include_pad=True) -> Tensor
static inline Tensor avg_pool1d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::avg_pool1d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool1d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool>(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
#endif
}

// aten::adaptive_avg_pool1d(Tensor self, int[1] output_size) -> Tensor
static inline Tensor adaptive_avg_pool1d(const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::adaptive_avg_pool1d(self, output_size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_avg_pool1d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, output_size);
#endif
}

// aten::adaptive_max_pool1d(Tensor self, int[1] output_size) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> adaptive_max_pool1d(const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::adaptive_max_pool1d(self, output_size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool1d", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef>(self, output_size);
#endif
}

// aten::add.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor
static inline Tensor add(const Tensor & self, const Tensor & other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::add_Tensor(self, other, alpha);
            break;
        default:
            AT_ERROR("add not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::add", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(self, other, alpha);
#endif
}

// aten::add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & add_out(Tensor & out, const Tensor & self, const Tensor & other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::add_out_out(out, self, other, alpha);
            break;
        default:
            AT_ERROR("add_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::add", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar>(out, self, other, alpha);
#endif
}

// aten::add.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor
static inline Tensor add(const Tensor & self, Scalar other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::add_Scalar(self, other, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::add", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar>(self, other, alpha);
#endif
}

// aten::addmv(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor
static inline Tensor addmv(const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, mat, vec);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::addmv(self, mat, vec, beta, alpha);
            break;
        default:
            AT_ERROR("addmv not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addmv", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, mat, vec, beta, alpha);
#endif
}

// aten::addmv_(Tensor(a!) self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!)
static inline Tensor & addmv_(Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, mat, vec);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::addmv_(self, mat, vec, beta, alpha);
            break;
        default:
            AT_ERROR("addmv_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addmv_", "");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, mat, vec, beta, alpha);
#endif
}

// aten::addmv.out(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & addmv_out(Tensor & out, const Tensor & self, const Tensor & mat, const Tensor & vec, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, mat, vec);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::addmv_out_out(out, self, mat, vec, beta, alpha);
            break;
        default:
            AT_ERROR("addmv_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addmv", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(out, self, mat, vec, beta, alpha);
#endif
}

// aten::addr(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
static inline Tensor addr(const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::addr(self, vec1, vec2, beta, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addr", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, vec1, vec2, beta, alpha);
#endif
}

// aten::addr.out(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & addr_out(Tensor & out, const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::addr_out_out(out, self, vec1, vec2, beta, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addr", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(out, self, vec1, vec2, beta, alpha);
#endif
}

// aten::affine_grid_generator(Tensor theta, int[] size, bool align_corners) -> Tensor
static inline Tensor affine_grid_generator(const Tensor & theta, IntArrayRef size, bool align_corners) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::affine_grid_generator(theta, size, align_corners);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::affine_grid_generator", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool>(theta, size, align_corners);
#endif
}

// aten::affine_grid_generator_backward(Tensor grad, int[] size, bool align_corners) -> Tensor
static inline Tensor affine_grid_generator_backward(const Tensor & grad, IntArrayRef size, bool align_corners) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::affine_grid_generator_backward(grad, size, align_corners);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::affine_grid_generator_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool>(grad, size, align_corners);
#endif
}

// aten::all.dim(Tensor self, int dim, bool keepdim=False) -> Tensor
static inline Tensor all(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::all_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::all", "dim");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::all.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & all_out(Tensor & out, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::all_out_out(out, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::all", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, bool>(out, self, dim, keepdim);
#endif
}

// aten::all.dimname(Tensor self, Dimname dim, bool keepdim=False) -> Tensor
static inline Tensor all(const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::all_dimname(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::all", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, bool>(self, dim, keepdim);
#endif
}

// aten::all.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & all_out(Tensor & out, const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::all_out_dimname_out(out, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::all", "dimname_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Dimname, bool>(out, self, dim, keepdim);
#endif
}

// aten::allclose(Tensor self, Tensor other, float rtol=1e-05, float atol=1e-08, bool equal_nan=False) -> bool
static inline bool allclose(const Tensor & self, const Tensor & other, double rtol, double atol, bool equal_nan) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::allclose(self, other, rtol, atol, equal_nan);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::allclose", "");
    return op.callUnboxed<bool, const Tensor &, const Tensor &, double, double, bool>(self, other, rtol, atol, equal_nan);
#endif
}

// aten::any.dim(Tensor self, int dim, bool keepdim=False) -> Tensor
static inline Tensor any(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::any_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::any", "dim");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::any.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & any_out(Tensor & out, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::any_out_out(out, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::any", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, bool>(out, self, dim, keepdim);
#endif
}

// aten::any.dimname(Tensor self, Dimname dim, bool keepdim=False) -> Tensor
static inline Tensor any(const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::any_dimname(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::any", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, bool>(self, dim, keepdim);
#endif
}

// aten::any.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & any_out(Tensor & out, const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::any_out_dimname_out(out, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::any", "dimname_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Dimname, bool>(out, self, dim, keepdim);
#endif
}

// aten::arange(Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor arange(Scalar end, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::arange(end, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::arange", "");
    return op.callUnboxed<Tensor, Scalar, const TensorOptions &>(end, options);
#endif
}

// aten::arange.start(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor arange(Scalar start, Scalar end, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::arange_start(start, end, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::arange", "start");
    return op.callUnboxed<Tensor, Scalar, Scalar, const TensorOptions &>(start, end, options);
#endif
}

// aten::arange.start_step(Scalar start, Scalar end, Scalar step, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor arange(Scalar start, Scalar end, Scalar step, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::arange_start_step(start, end, step, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::arange", "start_step");
    return op.callUnboxed<Tensor, Scalar, Scalar, Scalar, const TensorOptions &>(start, end, step, options);
#endif
}

// aten::arange.out(Scalar end, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & arange_out(Tensor & out, Scalar end) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::arange_out_out(out, end);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::arange", "out");
    return op.callUnboxed<Tensor &, Tensor &, Scalar>(out, end);
#endif
}

// aten::arange.start_out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & arange_out(Tensor & out, Scalar start, Scalar end, Scalar step) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::arange_out_start_out(out, start, end, step);
            break;
        default:
            AT_ERROR("arange_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::arange", "start_out");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, Scalar, Scalar>(out, start, end, step);
#endif
}

// aten::_dim_arange(Tensor like, int dim) -> Tensor
static inline Tensor _dim_arange(const Tensor & like, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_dim_arange(like, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_dim_arange", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(like, dim);
#endif
}

// aten::argmax(Tensor self, int? dim=None, bool keepdim=False) -> Tensor
static inline Tensor argmax(const Tensor & self, c10::optional<int64_t> dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::argmax(self, dim, keepdim);
            break;
        default:
            AT_ERROR("argmax not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::argmax", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<int64_t>, bool>(self, dim, keepdim);
#endif
}

// aten::argmin(Tensor self, int? dim=None, bool keepdim=False) -> Tensor
static inline Tensor argmin(const Tensor & self, c10::optional<int64_t> dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::argmin(self, dim, keepdim);
            break;
        default:
            AT_ERROR("argmin not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::argmin", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<int64_t>, bool>(self, dim, keepdim);
#endif
}

// aten::as_strided(Tensor(a) self, int[] size, int[] stride, int? storage_offset=None) -> Tensor(a)
static inline Tensor as_strided(const Tensor & self, IntArrayRef size, IntArrayRef stride, c10::optional<int64_t> storage_offset) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::as_strided(self, size, stride, storage_offset);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::as_strided(self, size, stride, storage_offset);
            break;
        default:
            AT_ERROR("as_strided not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::as_strided", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, c10::optional<int64_t>>(self, size, stride, storage_offset);
#endif
}

// aten::as_strided_(Tensor(a!) self, int[] size, int[] stride, int? storage_offset=None) -> Tensor(a!)
static inline Tensor & as_strided_(Tensor & self, IntArrayRef size, IntArrayRef stride, c10::optional<int64_t> storage_offset) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::as_strided_(self, size, stride, storage_offset);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::as_strided_", "");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef, IntArrayRef, c10::optional<int64_t>>(self, size, stride, storage_offset);
#endif
}

// aten::asin(Tensor self) -> Tensor
static inline Tensor asin(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::asin(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::asin", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::asin_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & asin_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::asin_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::asin_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::asin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & asin_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::asin_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::asin", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::atan(Tensor self) -> Tensor
static inline Tensor atan(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::atan(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::atan", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::atan_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & atan_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::atan_(self);
            break;
        default:
            AT_ERROR("atan_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::atan_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::atan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & atan_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::atan_out_out(out, self);
            break;
        default:
            AT_ERROR("atan_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::atan", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::baddbmm(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
static inline Tensor baddbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, batch1, batch2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::baddbmm(self, batch1, batch2, beta, alpha);
            break;
        default:
            AT_ERROR("baddbmm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::baddbmm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, batch1, batch2, beta, alpha);
#endif
}

// aten::_baddbmm_mkl_(Tensor(a!) self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!)
static inline Tensor & _baddbmm_mkl_(Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_baddbmm_mkl_(self, batch1, batch2, beta, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_baddbmm_mkl_", "");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, batch1, batch2, beta, alpha);
#endif
}

// aten::baddbmm.out(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & baddbmm_out(Tensor & out, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, batch1, batch2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::baddbmm_out_out(out, self, batch1, batch2, beta, alpha);
            break;
        default:
            AT_ERROR("baddbmm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::baddbmm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(out, self, batch1, batch2, beta, alpha);
#endif
}

// aten::bartlett_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor bartlett_window(int64_t window_length, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bartlett_window(window_length, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bartlett_window", "");
    return op.callUnboxed<Tensor, int64_t, const TensorOptions &>(window_length, options);
#endif
}

// aten::bartlett_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor bartlett_window(int64_t window_length, bool periodic, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bartlett_window_periodic(window_length, periodic, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bartlett_window", "periodic");
    return op.callUnboxed<Tensor, int64_t, bool, const TensorOptions &>(window_length, periodic, options);
#endif
}

// aten::batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, bool cudnn_enabled) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::batch_norm(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, double, bool>(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled);
#endif
}

// aten::quantized_batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor var, float eps, float output_scale, int output_zero_point) -> Tensor
static inline Tensor quantized_batch_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & mean, const Tensor & var, double eps, double output_scale, int64_t output_zero_point) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, bias, mean, var);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::quantized_batch_norm(input, weight, bias, mean, var, eps, output_scale, output_zero_point);
            break;
        default:
            AT_ERROR("quantized_batch_norm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_batch_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, double, double, int64_t>(input, weight, bias, mean, var, eps, output_scale, output_zero_point);
#endif
}

// aten::_batch_norm_impl_index(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, bool cudnn_enabled) -> (Tensor, Tensor, Tensor, Tensor, int)
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,int64_t> _batch_norm_impl_index(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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_batch_norm_impl_index(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_batch_norm_impl_index", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor,int64_t>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, double, bool>(input, weight, bias, running_mean, running_var, training, momentum, eps, cudnn_enabled);
#endif
}

// aten::_batch_norm_impl_index_backward(int impl_index, Tensor input, Tensor grad_output, Tensor? weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var_transform, bool train, float eps, bool[3] output_mask, Tensor reservedSpace) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> _batch_norm_impl_index_backward(int64_t impl_index, 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_transform, bool train, double eps, std::array<bool,3> output_mask, const Tensor & reservedSpace) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_batch_norm_impl_index_backward(impl_index, input, grad_output, weight, running_mean, running_var, save_mean, save_var_transform, train, eps, output_mask, reservedSpace);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_batch_norm_impl_index_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, int64_t, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, std::array<bool,3>, const Tensor &>(impl_index, input, grad_output, weight, running_mean, running_var, save_mean, save_var_transform, train, eps, output_mask, reservedSpace);
#endif
}

// aten::bernoulli(Tensor self, *, Generator? generator=None) -> Tensor
static inline Tensor bernoulli(const Tensor & self, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bernoulli(self, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bernoulli", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Generator>>(self, generator);
#endif
}

// aten::bernoulli.out(Tensor self, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bernoulli_out(Tensor & out, const Tensor & self, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bernoulli_out_out(out, self, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bernoulli", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, c10::optional<Generator>>(out, self, generator);
#endif
}

// aten::bernoulli.p(Tensor self, float p, *, Generator? generator=None) -> Tensor
static inline Tensor bernoulli(const Tensor & self, double p, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bernoulli_p(self, p, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bernoulli", "p");
    return op.callUnboxed<Tensor, const Tensor &, double, c10::optional<Generator>>(self, p, generator);
#endif
}

// aten::bilinear(Tensor input1, Tensor input2, Tensor weight, Tensor? bias) -> Tensor
static inline Tensor bilinear(const Tensor & input1, const Tensor & input2, const Tensor & weight, const Tensor & bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bilinear(input1, input2, weight, bias);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bilinear", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(input1, input2, weight, bias);
#endif
}

// aten::binary_cross_entropy(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor
static inline Tensor binary_cross_entropy(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::binary_cross_entropy(self, target, weight, reduction);
            break;
        default:
            AT_ERROR("binary_cross_entropy not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::binary_cross_entropy", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t>(self, target, weight, reduction);
#endif
}

// aten::binary_cross_entropy.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & binary_cross_entropy_out(Tensor & out, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::binary_cross_entropy_out_out(out, self, target, weight, reduction);
            break;
        default:
            AT_ERROR("binary_cross_entropy_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::binary_cross_entropy", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(out, self, target, weight, reduction);
#endif
}

// aten::binary_cross_entropy_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor
static inline Tensor binary_cross_entropy_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::binary_cross_entropy_backward(grad_output, self, target, weight, reduction);
            break;
        default:
            AT_ERROR("binary_cross_entropy_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::binary_cross_entropy_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_output, self, target, weight, reduction);
#endif
}

// aten::binary_cross_entropy_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::binary_cross_entropy_backward_out_grad_input(grad_input, grad_output, self, target, weight, reduction);
            break;
        default:
            AT_ERROR("binary_cross_entropy_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::binary_cross_entropy_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_input, grad_output, self, target, weight, reduction);
#endif
}

// aten::binary_cross_entropy_with_logits(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean) -> Tensor
static inline Tensor binary_cross_entropy_with_logits(const Tensor & self, const Tensor & target, const Tensor & weight, const Tensor & pos_weight, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::binary_cross_entropy_with_logits(self, target, weight, pos_weight, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::binary_cross_entropy_with_logits", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(self, target, weight, pos_weight, reduction);
#endif
}

// aten::binary_cross_entropy_with_logits_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::binary_cross_entropy_with_logits_backward(grad_output, self, target, weight, pos_weight, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::binary_cross_entropy_with_logits_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_output, self, target, weight, pos_weight, reduction);
#endif
}

// aten::bincount(Tensor self, Tensor? weights=None, int minlength=0) -> Tensor
static inline Tensor bincount(const Tensor & self, const Tensor & weights, int64_t minlength) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weights);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bincount(self, weights, minlength);
            break;
        default:
            AT_ERROR("bincount not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bincount", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(self, weights, minlength);
#endif
}

// aten::bitwise_not(Tensor self) -> Tensor
static inline Tensor bitwise_not(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bitwise_not(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_not", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::bitwise_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bitwise_not_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bitwise_not_out_out(out, self);
            break;
        default:
            AT_ERROR("bitwise_not_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_not", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::logical_not(Tensor self) -> Tensor
static inline Tensor logical_not(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logical_not(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logical_not", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::logical_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & logical_not_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::logical_not_out_out(out, self);
            break;
        default:
            AT_ERROR("logical_not_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logical_not", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::logical_xor(Tensor self, Tensor other) -> Tensor
static inline Tensor logical_xor(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logical_xor(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logical_xor", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::logical_xor.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & logical_xor_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::logical_xor_out_out(out, self, other);
            break;
        default:
            AT_ERROR("logical_xor_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logical_xor", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::logical_and(Tensor self, Tensor other) -> Tensor
static inline Tensor logical_and(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logical_and(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logical_and", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::logical_and.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & logical_and_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::logical_and_out_out(out, self, other);
            break;
        default:
            AT_ERROR("logical_and_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logical_and", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::logical_or(Tensor self, Tensor other) -> Tensor
static inline Tensor logical_or(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logical_or(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logical_or", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::logical_or.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & logical_or_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::logical_or_out_out(out, self, other);
            break;
        default:
            AT_ERROR("logical_or_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logical_or", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor blackman_window(int64_t window_length, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::blackman_window(window_length, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::blackman_window", "");
    return op.callUnboxed<Tensor, int64_t, const TensorOptions &>(window_length, options);
#endif
}

// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor blackman_window(int64_t window_length, bool periodic, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::blackman_window_periodic(window_length, periodic, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::blackman_window", "periodic");
    return op.callUnboxed<Tensor, int64_t, bool, const TensorOptions &>(window_length, periodic, options);
#endif
}

// aten::bmm(Tensor self, Tensor mat2) -> Tensor
static inline Tensor bmm(const Tensor & self, const Tensor & mat2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bmm(self, mat2);
            break;
        default:
            AT_ERROR("bmm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bmm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, mat2);
#endif
}

// aten::_bmm(Tensor self, Tensor mat2, *, bool deterministic=False) -> Tensor
static inline Tensor _bmm(const Tensor & self, const Tensor & mat2, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_bmm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_bmm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, bool>(self, mat2, deterministic);
#endif
}

// aten::bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bmm_out(Tensor & out, const Tensor & self, const Tensor & mat2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bmm_out_out(out, self, mat2);
            break;
        default:
            AT_ERROR("bmm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bmm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, mat2);
#endif
}

// aten::_bmm.out(Tensor self, Tensor mat2, *, bool deterministic=False, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & _bmm_out(Tensor & out, const Tensor & self, const Tensor & mat2, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_bmm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_bmm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, bool>(out, self, mat2, deterministic);
#endif
}

// aten::broadcast_tensors(Tensor[] tensors) -> Tensor[]
static inline std::vector<Tensor> broadcast_tensors(TensorList tensors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::broadcast_tensors(tensors);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::broadcast_tensors", "");
    return op.callUnboxed<std::vector<Tensor>, TensorList>(tensors);
#endif
}

// aten::cat(Tensor[] tensors, int dim=0) -> Tensor
static inline Tensor cat(TensorList tensors, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cat(tensors, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cat", "");
    return op.callUnboxed<Tensor, TensorList, int64_t>(tensors, dim);
#endif
}

// aten::cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cat_out(Tensor & out, TensorList tensors, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cat_out_out(out, tensors, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cat", "out");
    return op.callUnboxed<Tensor &, Tensor &, TensorList, int64_t>(out, tensors, dim);
#endif
}

// aten::cat.names(Tensor[] tensors, Dimname dim) -> Tensor
static inline Tensor cat(TensorList tensors, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cat_names(tensors, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cat", "names");
    return op.callUnboxed<Tensor, TensorList, Dimname>(tensors, dim);
#endif
}

// aten::cat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cat_out(Tensor & out, TensorList tensors, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cat_out_names_out(out, tensors, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cat", "names_out");
    return op.callUnboxed<Tensor &, Tensor &, TensorList, Dimname>(out, tensors, dim);
#endif
}

// aten::block_diag(Tensor[] tensors) -> Tensor
static inline Tensor block_diag(TensorList tensors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::block_diag(tensors);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::block_diag", "");
    return op.callUnboxed<Tensor, TensorList>(tensors);
#endif
}

// aten::ceil(Tensor self) -> Tensor
static inline Tensor ceil(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ceil(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ceil", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::ceil_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & ceil_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ceil_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ceil_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::ceil.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & ceil_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ceil_out_out(out, self);
            break;
        default:
            AT_ERROR("ceil_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ceil", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::chain_matmul(Tensor[] matrices) -> Tensor
static inline Tensor chain_matmul(TensorList matrices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::chain_matmul(matrices);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::chain_matmul", "");
    return op.callUnboxed<Tensor, TensorList>(matrices);
#endif
}

// aten::chunk(Tensor(a) self, int chunks, int dim=0) -> Tensor(a)[]
static inline std::vector<Tensor> chunk(const Tensor & self, int64_t chunks, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::chunk(self, chunks, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::chunk", "");
    return op.callUnboxed<std::vector<Tensor>, const Tensor &, int64_t, int64_t>(self, chunks, dim);
#endif
}

// aten::clamp(Tensor self, Scalar? min=None, Scalar? max=None) -> Tensor
static inline Tensor clamp(const Tensor & self, c10::optional<Scalar> min, c10::optional<Scalar> max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::clamp(self, min, max);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::clamp(self, min, max);
            break;
        default:
            AT_ERROR("clamp not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Scalar>, c10::optional<Scalar>>(self, min, max);
#endif
}

// aten::clamp_(Tensor(a!) self, Scalar? min=None, Scalar? max=None) -> Tensor(a!)
static inline Tensor & clamp_(Tensor & self, c10::optional<Scalar> min, c10::optional<Scalar> max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::clamp_(self, min, max);
            break;
        default:
            AT_ERROR("clamp_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp_", "");
    return op.callUnboxed<Tensor &, Tensor &, c10::optional<Scalar>, c10::optional<Scalar>>(self, min, max);
#endif
}

// aten::clamp.out(Tensor self, Scalar? min=None, Scalar? max=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & clamp_out(Tensor & out, const Tensor & self, c10::optional<Scalar> min, c10::optional<Scalar> max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::clamp_out_out(out, self, min, max);
            break;
        default:
            AT_ERROR("clamp_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, c10::optional<Scalar>, c10::optional<Scalar>>(out, self, min, max);
#endif
}

// aten::clamp_max(Tensor self, Scalar max) -> Tensor
static inline Tensor clamp_max(const Tensor & self, Scalar max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::clamp_max(self, max);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp_max", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, max);
#endif
}

// aten::clamp_max_(Tensor(a!) self, Scalar max) -> Tensor(a!)
static inline Tensor & clamp_max_(Tensor & self, Scalar max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::clamp_max_(self, max);
            break;
        default:
            AT_ERROR("clamp_max_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp_max_", "");
    return op.callUnboxed<Tensor &, Tensor &, Scalar>(self, max);
#endif
}

// aten::clamp_max.out(Tensor self, Scalar max, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & clamp_max_out(Tensor & out, const Tensor & self, Scalar max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::clamp_max_out_out(out, self, max);
            break;
        default:
            AT_ERROR("clamp_max_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp_max", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, max);
#endif
}

// aten::clamp_min(Tensor self, Scalar min) -> Tensor
static inline Tensor clamp_min(const Tensor & self, Scalar min) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::clamp_min(self, min);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp_min", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, min);
#endif
}

// aten::clamp_min_(Tensor(a!) self, Scalar min) -> Tensor(a!)
static inline Tensor & clamp_min_(Tensor & self, Scalar min) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::clamp_min_(self, min);
            break;
        default:
            AT_ERROR("clamp_min_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp_min_", "");
    return op.callUnboxed<Tensor &, Tensor &, Scalar>(self, min);
#endif
}

// aten::clamp_min.out(Tensor self, Scalar min, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & clamp_min_out(Tensor & out, const Tensor & self, Scalar min) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::clamp_min_out_out(out, self, min);
            break;
        default:
            AT_ERROR("clamp_min_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clamp_min", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, min);
#endif
}

// aten::cudnn_is_acceptable(Tensor self) -> bool
static inline bool cudnn_is_acceptable(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cudnn_is_acceptable(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_is_acceptable", "");
    return op.callUnboxed<bool, const Tensor &>(self);
#endif
}

// aten::constant_pad_nd(Tensor self, int[] pad, Scalar value=0) -> Tensor
static inline Tensor constant_pad_nd(const Tensor & self, IntArrayRef pad, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::constant_pad_nd(self, pad, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::constant_pad_nd", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, Scalar>(self, pad, value);
#endif
}

// aten::convolution(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups) -> Tensor
static inline Tensor convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding, int64_t groups) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::convolution(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::convolution", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, IntArrayRef, int64_t>(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
#endif
}

// aten::convolution_overrideable(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups) -> Tensor
static inline Tensor convolution_overrideable(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding, int64_t groups) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::convolution_overrideable(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::convolution_overrideable", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, IntArrayRef, int64_t>(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
#endif
}

// aten::convolution_backward_overrideable(Tensor grad_output, Tensor input, Tensor weight, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias)
static inline std::tuple<Tensor,Tensor,Tensor> convolution_backward_overrideable(const Tensor & grad_output, const Tensor & input, const Tensor & weight, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding, int64_t groups, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::convolution_backward_overrideable(grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::convolution_backward_overrideable", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, IntArrayRef, int64_t, std::array<bool,3>>(grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask);
#endif
}

// aten::_convolution(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled) -> Tensor
static inline Tensor _convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_convolution(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_convolution", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, IntArrayRef, int64_t, bool, bool, bool>(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled);
#endif
}

// aten::_convolution_nogroup(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding) -> Tensor
static inline Tensor _convolution_nogroup(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_convolution_nogroup(input, weight, bias, stride, padding, dilation, transposed, output_padding);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_convolution_nogroup", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, IntArrayRef>(input, weight, bias, stride, padding, dilation, transposed, output_padding);
#endif
}

// aten::_convolution_double_backward(Tensor? ggI, Tensor? ggW, Tensor? ggb, Tensor gO, Tensor weight, Tensor self, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
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, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool transposed, IntArrayRef output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_convolution_double_backward(ggI, ggW, ggb, gO, weight, self, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, output_mask);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_convolution_double_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, IntArrayRef, int64_t, bool, bool, bool, std::array<bool,3>>(ggI, ggW, ggb, gO, weight, self, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, output_mask);
#endif
}

// aten::conv1d(Tensor input, Tensor weight, Tensor? bias=None, int[1] stride=1, int[1] padding=0, int[1] dilation=1, int groups=1) -> Tensor
static inline Tensor conv1d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, int64_t groups) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conv1d(input, weight, bias, stride, padding, dilation, groups);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conv1d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t>(input, weight, bias, stride, padding, dilation, groups);
#endif
}

// aten::conv2d(Tensor input, Tensor weight, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] dilation=1, int groups=1) -> Tensor
static inline Tensor conv2d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, int64_t groups) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conv2d(input, weight, bias, stride, padding, dilation, groups);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conv2d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t>(input, weight, bias, stride, padding, dilation, groups);
#endif
}

// aten::conv3d(Tensor input, Tensor weight, Tensor? bias=None, int[3] stride=1, int[3] padding=0, int[3] dilation=1, int groups=1) -> Tensor
static inline Tensor conv3d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, int64_t groups) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conv3d(input, weight, bias, stride, padding, dilation, groups);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conv3d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t>(input, weight, bias, stride, padding, dilation, groups);
#endif
}

// aten::conv_tbc(Tensor self, Tensor weight, Tensor bias, int pad=0) -> Tensor
static inline Tensor conv_tbc(const Tensor & self, const Tensor & weight, const Tensor & bias, int64_t pad) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conv_tbc(self, weight, bias, pad);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conv_tbc", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t>(self, weight, bias, pad);
#endif
}

// aten::conv_tbc_backward(Tensor self, Tensor input, Tensor weight, Tensor bias, int pad) -> (Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conv_tbc_backward(self, input, weight, bias, pad);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conv_tbc_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(self, input, weight, bias, pad);
#endif
}

// aten::conv_transpose1d(Tensor input, Tensor weight, Tensor? bias=None, int[1] stride=1, int[1] padding=0, int[1] output_padding=0, int groups=1, int[1] dilation=1) -> Tensor
static inline Tensor conv_transpose1d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, int64_t groups, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conv_transpose1d(input, weight, bias, stride, padding, output_padding, groups, dilation);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conv_transpose1d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, IntArrayRef>(input, weight, bias, stride, padding, output_padding, groups, dilation);
#endif
}

// aten::conv_transpose2d.input(Tensor input, Tensor weight, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] output_padding=0, int groups=1, int[2] dilation=1) -> Tensor
static inline Tensor conv_transpose2d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, int64_t groups, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conv_transpose2d_input(input, weight, bias, stride, padding, output_padding, groups, dilation);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conv_transpose2d", "input");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, IntArrayRef>(input, weight, bias, stride, padding, output_padding, groups, dilation);
#endif
}

// aten::conv_transpose3d.input(Tensor input, Tensor weight, Tensor? bias=None, int[3] stride=1, int[3] padding=0, int[3] output_padding=0, int groups=1, int[3] dilation=1) -> Tensor
static inline Tensor conv_transpose3d(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, int64_t groups, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::conv_transpose3d_input(input, weight, bias, stride, padding, output_padding, groups, dilation);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::conv_transpose3d", "input");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, IntArrayRef>(input, weight, bias, stride, padding, output_padding, groups, dilation);
#endif
}

// aten::_copy_from(Tensor self, Tensor dst, bool non_blocking=False) -> Tensor
static inline Tensor _copy_from(const Tensor & self, const Tensor & dst, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, dst);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_copy_from not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_copy_from", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, bool>(self, dst, non_blocking);
#endif
}

// aten::cos(Tensor self) -> Tensor
static inline Tensor cos(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cos(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cos", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::cos_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & cos_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::cos_(self);
            break;
        default:
            AT_ERROR("cos_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cos_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::cos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cos_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::cos_out_out(out, self);
            break;
        default:
            AT_ERROR("cos_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cos", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::cosh(Tensor self) -> Tensor
static inline Tensor cosh(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cosh(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cosh", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::cosh_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & cosh_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cosh_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cosh_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::cosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cosh_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cosh_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cosh", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::cosine_embedding_loss(Tensor input1, Tensor input2, Tensor target, float margin=0.0, int reduction=Mean) -> Tensor
static inline Tensor cosine_embedding_loss(const Tensor & input1, const Tensor & input2, const Tensor & target, double margin, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cosine_embedding_loss(input1, input2, target, margin, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cosine_embedding_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, double, int64_t>(input1, input2, target, margin, reduction);
#endif
}

// aten::cudnn_affine_grid_generator(Tensor theta, int N, int C, int H, int W) -> Tensor grid
static inline Tensor cudnn_affine_grid_generator(const Tensor & theta, int64_t N, int64_t C, int64_t H, int64_t W) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(theta);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_affine_grid_generator not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_affine_grid_generator", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t, int64_t, int64_t>(theta, N, C, H, W);
#endif
}

// aten::cudnn_affine_grid_generator_backward(Tensor grad, int N, int C, int H, int W) -> Tensor grad_theta
static inline Tensor cudnn_affine_grid_generator_backward(const Tensor & grad, int64_t N, int64_t C, int64_t H, int64_t W) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_affine_grid_generator_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_affine_grid_generator_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t, int64_t, int64_t>(grad, N, C, H, W);
#endif
}

// aten::cudnn_batch_norm(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon) -> (Tensor, Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, bias, running_mean, running_var);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_batch_norm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_batch_norm", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, double>(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon);
#endif
}

// aten::cudnn_batch_norm_backward(Tensor input, Tensor grad_output, Tensor weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var, float epsilon, Tensor reserveSpace) -> (Tensor, Tensor, Tensor)
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, const Tensor & reserveSpace) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, grad_output, weight, running_mean, running_var, save_mean, save_var, reserveSpace);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_batch_norm_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_batch_norm_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, double, const Tensor &>(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, reserveSpace);
#endif
}

// aten::cudnn_convolution.deprecated(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor cudnn_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution", "deprecated");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::cudnn_convolution(Tensor self, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor cudnn_convolution(const Tensor & self, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self, weight, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::cudnn_convolution_backward_input(int[] self_size, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor cudnn_convolution_backward_input(IntArrayRef self_size, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution_backward_input not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution_backward_input", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self_size, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::cudnn_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool[2] output_mask) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> cudnn_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,2> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool, std::array<bool,2>>(self, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic, output_mask);
#endif
}

// aten::cudnn_convolution_backward_weight(int[] weight_size, Tensor grad_output, Tensor self, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor cudnn_convolution_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution_backward_weight not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution_backward_weight", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::cudnn_convolution_transpose.deprecated(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor cudnn_convolution_transpose(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution_transpose not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution_transpose", "deprecated");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::cudnn_convolution_transpose(Tensor self, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor cudnn_convolution_transpose(const Tensor & self, const Tensor & weight, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution_transpose not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution_transpose", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::cudnn_convolution_transpose_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool[2] output_mask) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> cudnn_convolution_transpose_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,2> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution_transpose_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution_transpose_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool, std::array<bool,2>>(self, grad_output, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, output_mask);
#endif
}

// aten::cudnn_convolution_transpose_backward_input(Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor cudnn_convolution_transpose_backward_input(const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution_transpose_backward_input not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution_transpose_backward_input", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::cudnn_convolution_transpose_backward_weight(int[] weight_size, Tensor grad_output, Tensor self, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor cudnn_convolution_transpose_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_convolution_transpose_backward_weight not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_convolution_transpose_backward_weight", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::cudnn_grid_sampler(Tensor self, Tensor grid) -> Tensor output
static inline Tensor cudnn_grid_sampler(const Tensor & self, const Tensor & grid) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, grid);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_grid_sampler not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_grid_sampler", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, grid);
#endif
}

// aten::cudnn_grid_sampler_backward(Tensor self, Tensor grid, Tensor grad_output) -> (Tensor grad_self, Tensor grad_grid)
static inline std::tuple<Tensor,Tensor> cudnn_grid_sampler_backward(const Tensor & self, const Tensor & grid, const Tensor & grad_output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, grid, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("cudnn_grid_sampler_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cudnn_grid_sampler_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &>(self, grid, grad_output);
#endif
}

// aten::cummax(Tensor self, int dim) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> cummax(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cummax(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cummax", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::cummax.out(Tensor self, int dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> cummax_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cummax_out_out(values, indices, self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cummax", "out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t>(values, indices, self, dim);
#endif
}

// aten::cummax.dimname(Tensor self, Dimname dim) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> cummax(const Tensor & self, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cummax_dimname(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cummax", "dimname");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, Dimname>(self, dim);
#endif
}

// aten::cummax.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> cummax_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cummax_out_dimname_out(values, indices, self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cummax", "dimname_out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, Dimname>(values, indices, self, dim);
#endif
}

// aten::_cummax_helper(Tensor self, Tensor(a!) values, Tensor(b!) indices, int dim) -> ()
static inline void _cummax_helper(const Tensor & self, Tensor & values, Tensor & indices, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, values, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
         CPUType::_cummax_helper(self, values, indices, dim);
            break;
        default:
            AT_ERROR("_cummax_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cummax_helper", "");
    return op.callUnboxed<void, const Tensor &, Tensor &, Tensor &, int64_t>(self, values, indices, dim);
#endif
}

// aten::cummin(Tensor self, int dim) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> cummin(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cummin(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cummin", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::cummin.out(Tensor self, int dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> cummin_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cummin_out_out(values, indices, self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cummin", "out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t>(values, indices, self, dim);
#endif
}

// aten::cummin.dimname(Tensor self, Dimname dim) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> cummin(const Tensor & self, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cummin_dimname(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cummin", "dimname");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, Dimname>(self, dim);
#endif
}

// aten::cummin.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> cummin_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cummin_out_dimname_out(values, indices, self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cummin", "dimname_out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, Dimname>(values, indices, self, dim);
#endif
}

// aten::_cummin_helper(Tensor self, Tensor(a!) values, Tensor(b!) indices, int dim) -> ()
static inline void _cummin_helper(const Tensor & self, Tensor & values, Tensor & indices, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, values, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
         CPUType::_cummin_helper(self, values, indices, dim);
            break;
        default:
            AT_ERROR("_cummin_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cummin_helper", "");
    return op.callUnboxed<void, const Tensor &, Tensor &, Tensor &, int64_t>(self, values, indices, dim);
#endif
}

// aten::cumprod(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor
static inline Tensor cumprod(const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cumprod(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cumprod", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, c10::optional<ScalarType>>(self, dim, dtype);
#endif
}

// aten::cumprod.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cumprod_out(Tensor & out, const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cumprod_out_out(out, self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cumprod", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, c10::optional<ScalarType>>(out, self, dim, dtype);
#endif
}

// aten::cumprod.dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor
static inline Tensor cumprod(const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cumprod_dimname(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cumprod", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, c10::optional<ScalarType>>(self, dim, dtype);
#endif
}

// aten::cumprod.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cumprod_out(Tensor & out, const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cumprod_out_dimname_out(out, self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cumprod", "dimname_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Dimname, c10::optional<ScalarType>>(out, self, dim, dtype);
#endif
}

// aten::cumsum(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor
static inline Tensor cumsum(const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cumsum(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cumsum", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, c10::optional<ScalarType>>(self, dim, dtype);
#endif
}

// aten::cumsum.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cumsum_out(Tensor & out, const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cumsum_out_out(out, self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cumsum", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, c10::optional<ScalarType>>(out, self, dim, dtype);
#endif
}

// aten::cumsum.dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor
static inline Tensor cumsum(const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cumsum_dimname(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cumsum", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, c10::optional<ScalarType>>(self, dim, dtype);
#endif
}

// aten::cumsum.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cumsum_out(Tensor & out, const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cumsum_out_dimname_out(out, self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cumsum", "dimname_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Dimname, c10::optional<ScalarType>>(out, self, dim, dtype);
#endif
}

// aten::ctc_loss.IntList(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank=0, int reduction=Mean, bool zero_infinity=False) -> Tensor
static inline Tensor ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank, int64_t reduction, bool zero_infinity) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ctc_loss_IntList(log_probs, targets, input_lengths, target_lengths, blank, reduction, zero_infinity);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ctc_loss", "IntList");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, int64_t, int64_t, bool>(log_probs, targets, input_lengths, target_lengths, blank, reduction, zero_infinity);
#endif
}

// aten::ctc_loss.Tensor(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, int blank=0, int reduction=Mean, bool zero_infinity=False) -> Tensor
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, bool zero_infinity) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ctc_loss_Tensor(log_probs, targets, input_lengths, target_lengths, blank, reduction, zero_infinity);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ctc_loss", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, bool>(log_probs, targets, input_lengths, target_lengths, blank, reduction, zero_infinity);
#endif
}

// aten::_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank=0, bool zero_infinity=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _ctc_loss(const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, int64_t blank, bool zero_infinity) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(log_probs, targets);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_ctc_loss(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity);
            break;
        default:
            AT_ERROR("_ctc_loss not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_ctc_loss", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, int64_t, bool>(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity);
#endif
}

// aten::_ctc_loss_backward(Tensor grad, Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, int blank, bool zero_infinity=False) -> Tensor
static inline Tensor _ctc_loss_backward(const Tensor & grad, const Tensor & log_probs, const Tensor & targets, IntArrayRef input_lengths, IntArrayRef target_lengths, const Tensor & neg_log_likelihood, const Tensor & log_alpha, int64_t blank, bool zero_infinity) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad, log_probs, targets, neg_log_likelihood, log_alpha);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_ctc_loss_backward(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank, zero_infinity);
            break;
        default:
            AT_ERROR("_ctc_loss_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_ctc_loss_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &, int64_t, bool>(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank, zero_infinity);
#endif
}

// aten::det(Tensor self) -> Tensor
static inline Tensor det(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::det(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::det", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::diag_embed(Tensor self, int offset=0, int dim1=-2, int dim2=-1) -> Tensor
static inline Tensor diag_embed(const Tensor & self, int64_t offset, int64_t dim1, int64_t dim2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::diag_embed(self, offset, dim1, dim2);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::diag_embed", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t, int64_t>(self, offset, dim1, dim2);
#endif
}

// aten::diagflat(Tensor self, int offset=0) -> Tensor
static inline Tensor diagflat(const Tensor & self, int64_t offset) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::diagflat(self, offset);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::diagflat", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, offset);
#endif
}

// aten::diagonal(Tensor(a) self, int offset=0, int dim1=0, int dim2=1) -> Tensor(a)
static inline Tensor diagonal(const Tensor & self, int64_t offset, int64_t dim1, int64_t dim2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::diagonal(self, offset, dim1, dim2);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::diagonal", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t, int64_t>(self, offset, dim1, dim2);
#endif
}

// aten::diagonal.Dimname(Tensor(a) self, *, Dimname outdim, Dimname dim1, Dimname dim2, int offset=0) -> Tensor(a)
static inline Tensor diagonal(const Tensor & self, Dimname outdim, Dimname dim1, Dimname dim2, int64_t offset) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::diagonal_Dimname(self, outdim, dim1, dim2, offset);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::diagonal", "Dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, Dimname, Dimname, int64_t>(self, outdim, dim1, dim2, offset);
#endif
}

// aten::div.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor div(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::div_Tensor(self, other);
            break;
        default:
            AT_ERROR("div not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::div", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::div.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & div_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::div_out_out(out, self, other);
            break;
        default:
            AT_ERROR("div_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::div", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::div.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor div(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::div_Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::div", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::dot(Tensor self, Tensor tensor) -> Tensor
static inline Tensor dot(const Tensor & self, const Tensor & tensor) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, tensor);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::dot(self, tensor);
            break;
        default:
            AT_ERROR("dot not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::dot", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, tensor);
#endif
}

// aten::dot.out(Tensor self, Tensor tensor, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & dot_out(Tensor & out, const Tensor & self, const Tensor & tensor) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::dot_out_out(out, self, tensor);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::dot", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, tensor);
#endif
}

// aten::einsum(str equation, Tensor[] tensors) -> Tensor
static inline Tensor einsum(std::string equation, TensorList tensors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::einsum(equation, tensors);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::einsum", "");
    return op.callUnboxed<Tensor, std::string, TensorList>(equation, tensors);
#endif
}

// aten::embedding(Tensor weight, Tensor indices, int padding_idx=-1, bool scale_grad_by_freq=False, bool sparse=False) -> Tensor
static inline Tensor embedding(const Tensor & weight, const Tensor & indices, int64_t padding_idx, bool scale_grad_by_freq, bool sparse) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::embedding(weight, indices, padding_idx, scale_grad_by_freq, sparse);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::embedding", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, bool, bool>(weight, indices, padding_idx, scale_grad_by_freq, sparse);
#endif
}

// aten::embedding_backward(Tensor grad, Tensor indices, int num_weights, int padding_idx, bool scale_grad_by_freq, bool sparse) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::embedding_backward(grad, indices, num_weights, padding_idx, scale_grad_by_freq, sparse);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::embedding_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, int64_t, bool, bool>(grad, indices, num_weights, padding_idx, scale_grad_by_freq, sparse);
#endif
}

// aten::embedding_dense_backward(Tensor grad_output, Tensor indices, int num_weights, int padding_idx, bool scale_grad_by_freq) -> Tensor
static inline Tensor embedding_dense_backward(const Tensor & grad_output, const Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::embedding_dense_backward(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq);
            break;
        default:
            AT_ERROR("embedding_dense_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::embedding_dense_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, int64_t, bool>(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq);
#endif
}

// aten::embedding_renorm_(Tensor(a!) self, Tensor indices, float max_norm, float norm_type) -> Tensor(a!)
static inline Tensor & embedding_renorm_(Tensor & self, const Tensor & indices, double max_norm, double norm_type) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::embedding_renorm_(self, indices, max_norm, norm_type);
            break;
        default:
            AT_ERROR("embedding_renorm_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::embedding_renorm_", "");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, double, double>(self, indices, max_norm, norm_type);
#endif
}

// aten::embedding_sparse_backward(Tensor grad, Tensor indices, int num_weights, int padding_idx, bool scale_grad_by_freq) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::embedding_sparse_backward(grad, indices, num_weights, padding_idx, scale_grad_by_freq);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::embedding_sparse_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, int64_t, bool>(grad, indices, num_weights, padding_idx, scale_grad_by_freq);
#endif
}

// aten::embedding_bag(Tensor weight, Tensor indices, Tensor offsets, bool scale_grad_by_freq=False, int mode=0, bool sparse=False, Tensor? per_sample_weights=None, bool include_last_offset=False) -> (Tensor, Tensor, Tensor, Tensor)
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, const Tensor & per_sample_weights, bool include_last_offset) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::embedding_bag(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::embedding_bag", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, bool, int64_t, bool, const Tensor &, bool>(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset);
#endif
}

// aten::_embedding_bag(Tensor weight, Tensor indices, Tensor offsets, bool scale_grad_by_freq=False, int mode=0, bool sparse=False, Tensor? per_sample_weights=None, bool include_last_offset=False) -> (Tensor, Tensor, Tensor, Tensor)
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, const Tensor & per_sample_weights, bool include_last_offset) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(weight, indices, offsets, per_sample_weights);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_embedding_bag(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset);
            break;
        default:
            AT_ERROR("_embedding_bag not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_embedding_bag", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, bool, int64_t, bool, const Tensor &, bool>(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset);
#endif
}

// aten::_embedding_bag_backward(Tensor grad, Tensor indices, Tensor offsets, Tensor offset2bag, Tensor bag_size, Tensor maximum_indices, int num_weights, bool scale_grad_by_freq, int mode, bool sparse, Tensor? per_sample_weights) -> Tensor
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, const Tensor & per_sample_weights) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_embedding_bag_backward(grad, indices, offsets, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, sparse, per_sample_weights);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_embedding_bag_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, bool, int64_t, bool, const Tensor &>(grad, indices, offsets, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, sparse, per_sample_weights);
#endif
}

// aten::_embedding_bag_sparse_backward(Tensor grad, Tensor indices, Tensor offsets, Tensor offset2bag, Tensor bag_size, int num_weights, bool scale_grad_by_freq, int mode, Tensor? per_sample_weights) -> Tensor
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, const Tensor & per_sample_weights) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_embedding_bag_sparse_backward(grad, indices, offsets, offset2bag, bag_size, num_weights, scale_grad_by_freq, mode, per_sample_weights);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_embedding_bag_sparse_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, bool, int64_t, const Tensor &>(grad, indices, offsets, offset2bag, bag_size, num_weights, scale_grad_by_freq, mode, per_sample_weights);
#endif
}

// aten::_embedding_bag_dense_backward(Tensor grad, Tensor indices, Tensor offsets, Tensor offset2bag, Tensor bag_size, Tensor maximum_indices, int num_weights, bool scale_grad_by_freq, int mode, Tensor? per_sample_weights) -> Tensor
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, const Tensor & per_sample_weights) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad, indices, offsets, offset2bag, bag_size, maximum_indices, per_sample_weights);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_embedding_bag_dense_backward(grad, indices, offsets, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights);
            break;
        default:
            AT_ERROR("_embedding_bag_dense_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_embedding_bag_dense_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, bool, int64_t, const Tensor &>(grad, indices, offsets, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights);
#endif
}

// aten::_embedding_bag_per_sample_weights_backward(Tensor grad, Tensor weight, Tensor indices, Tensor offsets, Tensor offset2bag, int mode) -> Tensor
static inline Tensor _embedding_bag_per_sample_weights_backward(const Tensor & grad, const Tensor & weight, const Tensor & indices, const Tensor & offsets, const Tensor & offset2bag, int64_t mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad, weight, indices, offsets, offset2bag);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_embedding_bag_per_sample_weights_backward(grad, weight, indices, offsets, offset2bag, mode);
            break;
        default:
            AT_ERROR("_embedding_bag_per_sample_weights_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_embedding_bag_per_sample_weights_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad, weight, indices, offsets, offset2bag, mode);
#endif
}

// aten::empty.names(int[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor empty(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::empty_names(size, names, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::empty", "names");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<DimnameList>, const TensorOptions &, c10::optional<MemoryFormat>>(size, names, options, memory_format);
#endif
}

// aten::empty.memory_format(int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor empty(IntArrayRef size, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKey _dk = options.computeDispatchKey();
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::empty_memory_format(size, options, memory_format);
            break;
        default:
            AT_ERROR("empty not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::empty", "memory_format");
    return op.callUnboxed<Tensor, IntArrayRef, const TensorOptions &, c10::optional<MemoryFormat>>(size, options, memory_format);
#endif
}

// aten::_empty_affine_quantized(int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, float scale=1, int zero_point=0, MemoryFormat? memory_format=contiguous_format) -> Tensor
static inline Tensor _empty_affine_quantized(IntArrayRef size, const TensorOptions & options, double scale, int64_t zero_point, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKey _dk = options.computeDispatchKey();
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_empty_affine_quantized(size, options, scale, zero_point, memory_format);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::_empty_affine_quantized(size, options, scale, zero_point, memory_format);
            break;
        default:
            AT_ERROR("_empty_affine_quantized not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_empty_affine_quantized", "");
    return op.callUnboxed<Tensor, IntArrayRef, const TensorOptions &, double, int64_t, c10::optional<MemoryFormat>>(size, options, scale, zero_point, memory_format);
#endif
}

// aten::_empty_per_channel_affine_quantized(int[] size, *, Tensor scales, Tensor zero_points, int axis, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=contiguous_format) -> Tensor
static inline Tensor _empty_per_channel_affine_quantized(IntArrayRef size, const Tensor & scales, const Tensor & zero_points, int64_t axis, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = DispatchKeySet(options.computeDispatchKey()) | c10::detail::multi_dispatch_key_set(scales, zero_points);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_empty_per_channel_affine_quantized(size, scales, zero_points, axis, options, memory_format);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::_empty_per_channel_affine_quantized(size, scales, zero_points, axis, options, memory_format);
            break;
        default:
            AT_ERROR("_empty_per_channel_affine_quantized not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_empty_per_channel_affine_quantized", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, int64_t, const TensorOptions &, c10::optional<MemoryFormat>>(size, scales, zero_points, axis, options, memory_format);
#endif
}

// aten::empty.out(int[] size, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & empty_out(Tensor & out, IntArrayRef size, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::empty_out_out(out, size, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::empty", "out");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef, c10::optional<MemoryFormat>>(out, size, memory_format);
#endif
}

// aten::empty_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor empty_like(const Tensor & self, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::empty_like(self, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::empty_like", "");
    return op.callUnboxed<Tensor, const Tensor &, const TensorOptions &, c10::optional<MemoryFormat>>(self, options, memory_format);
#endif
}

// aten::empty_strided(int[] size, int[] stride, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor empty_strided(IntArrayRef size, IntArrayRef stride, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKey _dk = options.computeDispatchKey();
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::empty_strided(size, stride, options);
            break;
        default:
            AT_ERROR("empty_strided not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::empty_strided", "");
    return op.callUnboxed<Tensor, IntArrayRef, IntArrayRef, const TensorOptions &>(size, stride, options);
#endif
}

// aten::erf(Tensor self) -> Tensor
static inline Tensor erf(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::erf(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::erf", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::erf_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & erf_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::erf_(self);
            break;
        default:
            AT_ERROR("erf_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::erf_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::erf.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & erf_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::erf_out_out(out, self);
            break;
        default:
            AT_ERROR("erf_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::erf", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::erfc(Tensor self) -> Tensor
static inline Tensor erfc(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::erfc(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::erfc", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::erfc_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & erfc_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::erfc_(self);
            break;
        default:
            AT_ERROR("erfc_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::erfc_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::erfc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & erfc_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::erfc_out_out(out, self);
            break;
        default:
            AT_ERROR("erfc_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::erfc", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::exp(Tensor self) -> Tensor
static inline Tensor exp(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::exp(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::exp", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::exp_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & exp_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::exp_(self);
            break;
        default:
            AT_ERROR("exp_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::exp_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::exp.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & exp_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::exp_out_out(out, self);
            break;
        default:
            AT_ERROR("exp_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::exp", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::expm1(Tensor self) -> Tensor
static inline Tensor expm1(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::expm1(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::expm1", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::expm1_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & expm1_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::expm1_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::expm1_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::expm1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & expm1_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::expm1_out_out(out, self);
            break;
        default:
            AT_ERROR("expm1_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::expm1", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::eye(int n, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor eye(int64_t n, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::eye(n, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eye", "");
    return op.callUnboxed<Tensor, int64_t, const TensorOptions &>(n, options);
#endif
}

// aten::eye.m(int n, int m, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor eye(int64_t n, int64_t m, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::eye_m(n, m, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eye", "m");
    return op.callUnboxed<Tensor, int64_t, int64_t, const TensorOptions &>(n, m, options);
#endif
}

// aten::eye.out(int n, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & eye_out(Tensor & out, int64_t n) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::eye_out_out(out, n);
            break;
        default:
            AT_ERROR("eye_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eye", "out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t>(out, n);
#endif
}

// aten::eye.m_out(int n, int m, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & eye_out(Tensor & out, int64_t n, int64_t m) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::eye_out_m_out(out, n, m);
            break;
        default:
            AT_ERROR("eye_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eye", "m_out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, int64_t>(out, n, m);
#endif
}

// aten::flatten.using_ints(Tensor self, int start_dim=0, int end_dim=-1) -> Tensor
static inline Tensor flatten(const Tensor & self, int64_t start_dim, int64_t end_dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::flatten_using_ints(self, start_dim, end_dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::flatten", "using_ints");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t>(self, start_dim, end_dim);
#endif
}

// aten::flatten.named_out_dim(Tensor self, int start_dim, int end_dim, Dimname out_dim) -> Tensor
static inline Tensor flatten(const Tensor & self, int64_t start_dim, int64_t end_dim, Dimname out_dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::flatten_named_out_dim(self, start_dim, end_dim, out_dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::flatten", "named_out_dim");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t, Dimname>(self, start_dim, end_dim, out_dim);
#endif
}

// aten::flatten.using_names(Tensor self, Dimname start_dim, Dimname end_dim, Dimname out_dim) -> Tensor
static inline Tensor flatten(const Tensor & self, Dimname start_dim, Dimname end_dim, Dimname out_dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::flatten_using_names(self, start_dim, end_dim, out_dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::flatten", "using_names");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, Dimname, Dimname>(self, start_dim, end_dim, out_dim);
#endif
}

// aten::flatten.DimnameList(Tensor self, Dimname[] dims, Dimname out_dim) -> Tensor
static inline Tensor flatten(const Tensor & self, DimnameList dims, Dimname out_dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::flatten_DimnameList(self, dims, out_dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::flatten", "DimnameList");
    return op.callUnboxed<Tensor, const Tensor &, DimnameList, Dimname>(self, dims, out_dim);
#endif
}

// aten::fill_.Scalar(Tensor(a!) self, Scalar value) -> Tensor(a!)
static inline Tensor & fill_(Tensor & self, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fill__Scalar(self, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fill_", "Scalar");
    return op.callUnboxed<Tensor &, Tensor &, Scalar>(self, value);
#endif
}

// aten::fill_.Tensor(Tensor(a!) self, Tensor value) -> Tensor(a!)
static inline Tensor & fill_(Tensor & self, const Tensor & value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fill__Tensor(self, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fill_", "Tensor");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(self, value);
#endif
}

// aten::floor(Tensor self) -> Tensor
static inline Tensor floor(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::floor(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::floor", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::floor_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & floor_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::floor_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::floor_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::floor.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & floor_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::floor_out_out(out, self);
            break;
        default:
            AT_ERROR("floor_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::floor", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::floor_divide(Tensor self, Tensor other) -> Tensor
static inline Tensor floor_divide(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::floor_divide(self, other);
            break;
        default:
            AT_ERROR("floor_divide not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::floor_divide", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::floor_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & floor_divide_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::floor_divide_out_out(out, self, other);
            break;
        default:
            AT_ERROR("floor_divide_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::floor_divide", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::floor_divide.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor floor_divide(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::floor_divide_Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::floor_divide", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::frac(Tensor self) -> Tensor
static inline Tensor frac(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::frac(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::frac", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::frac_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & frac_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::frac_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::frac_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::frac.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & frac_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::frac_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::frac", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::full.names(int[] size, Scalar fill_value, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor full(IntArrayRef size, Scalar fill_value, c10::optional<DimnameList> names, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::full_names(size, fill_value, names, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::full", "names");
    return op.callUnboxed<Tensor, IntArrayRef, Scalar, c10::optional<DimnameList>, const TensorOptions &>(size, fill_value, names, options);
#endif
}

// aten::full(int[] size, Scalar fill_value, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor full(IntArrayRef size, Scalar fill_value, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::full(size, fill_value, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::full", "");
    return op.callUnboxed<Tensor, IntArrayRef, Scalar, const TensorOptions &>(size, fill_value, options);
#endif
}

// aten::full.out(int[] size, Scalar fill_value, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & full_out(Tensor & out, IntArrayRef size, Scalar fill_value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::full_out_out(out, size, fill_value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::full", "out");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef, Scalar>(out, size, fill_value);
#endif
}

// aten::full_like(Tensor self, Scalar fill_value, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor full_like(const Tensor & self, Scalar fill_value, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::full_like(self, fill_value, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::full_like", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, const TensorOptions &, c10::optional<MemoryFormat>>(self, fill_value, options, memory_format);
#endif
}

// aten::from_file(str filename, bool? shared=None, int? size=0, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor from_file(std::string filename, c10::optional<bool> shared, c10::optional<int64_t> size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKey _dk = options.computeDispatchKey();
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::from_file(filename, shared, size, options);
            break;
        default:
            AT_ERROR("from_file not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::from_file", "");
    return op.callUnboxed<Tensor, std::string, c10::optional<bool>, c10::optional<int64_t>, const TensorOptions &>(filename, shared, size, options);
#endif
}

// aten::grid_sampler(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> Tensor
static inline Tensor grid_sampler(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::grid_sampler(input, grid, interpolation_mode, padding_mode, align_corners);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::grid_sampler", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, int64_t, bool>(input, grid, interpolation_mode, padding_mode, align_corners);
#endif
}

// aten::grid_sampler_2d(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> Tensor
static inline Tensor grid_sampler_2d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, grid);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::grid_sampler_2d(input, grid, interpolation_mode, padding_mode, align_corners);
            break;
        default:
            AT_ERROR("grid_sampler_2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::grid_sampler_2d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, int64_t, bool>(input, grid, interpolation_mode, padding_mode, align_corners);
#endif
}

// aten::grid_sampler_2d_backward(Tensor grad_output, Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> (Tensor, Tensor)
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, bool align_corners) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, input, grid);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::grid_sampler_2d_backward(grad_output, input, grid, interpolation_mode, padding_mode, align_corners);
            break;
        default:
            AT_ERROR("grid_sampler_2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::grid_sampler_2d_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, bool>(grad_output, input, grid, interpolation_mode, padding_mode, align_corners);
#endif
}

// aten::grid_sampler_3d(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> Tensor
static inline Tensor grid_sampler_3d(const Tensor & input, const Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, grid);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::grid_sampler_3d(input, grid, interpolation_mode, padding_mode, align_corners);
            break;
        default:
            AT_ERROR("grid_sampler_3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::grid_sampler_3d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, int64_t, bool>(input, grid, interpolation_mode, padding_mode, align_corners);
#endif
}

// aten::grid_sampler_3d_backward(Tensor grad_output, Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> (Tensor, Tensor)
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, bool align_corners) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, input, grid);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::grid_sampler_3d_backward(grad_output, input, grid, interpolation_mode, padding_mode, align_corners);
            break;
        default:
            AT_ERROR("grid_sampler_3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::grid_sampler_3d_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, bool>(grad_output, input, grid, interpolation_mode, padding_mode, align_corners);
#endif
}

// aten::hann_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor hann_window(int64_t window_length, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hann_window(window_length, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hann_window", "");
    return op.callUnboxed<Tensor, int64_t, const TensorOptions &>(window_length, options);
#endif
}

// aten::hann_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor hann_window(int64_t window_length, bool periodic, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hann_window_periodic(window_length, periodic, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hann_window", "periodic");
    return op.callUnboxed<Tensor, int64_t, bool, const TensorOptions &>(window_length, periodic, options);
#endif
}

// aten::hamming_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor hamming_window(int64_t window_length, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hamming_window(window_length, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hamming_window", "");
    return op.callUnboxed<Tensor, int64_t, const TensorOptions &>(window_length, options);
#endif
}

// aten::hamming_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor hamming_window(int64_t window_length, bool periodic, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hamming_window_periodic(window_length, periodic, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hamming_window", "periodic");
    return op.callUnboxed<Tensor, int64_t, bool, const TensorOptions &>(window_length, periodic, options);
#endif
}

// aten::hamming_window.periodic_alpha(int window_length, bool periodic, float alpha, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor hamming_window(int64_t window_length, bool periodic, double alpha, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hamming_window_periodic_alpha(window_length, periodic, alpha, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hamming_window", "periodic_alpha");
    return op.callUnboxed<Tensor, int64_t, bool, double, const TensorOptions &>(window_length, periodic, alpha, options);
#endif
}

// aten::hamming_window.periodic_alpha_beta(int window_length, bool periodic, float alpha, float beta, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor hamming_window(int64_t window_length, bool periodic, double alpha, double beta, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hamming_window_periodic_alpha_beta(window_length, periodic, alpha, beta, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hamming_window", "periodic_alpha_beta");
    return op.callUnboxed<Tensor, int64_t, bool, double, double, const TensorOptions &>(window_length, periodic, alpha, beta, options);
#endif
}

// aten::hinge_embedding_loss(Tensor self, Tensor target, float margin=1.0, int reduction=Mean) -> Tensor
static inline Tensor hinge_embedding_loss(const Tensor & self, const Tensor & target, double margin, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hinge_embedding_loss(self, target, margin, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hinge_embedding_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, double, int64_t>(self, target, margin, reduction);
#endif
}

// aten::ger(Tensor self, Tensor vec2) -> Tensor
static inline Tensor ger(const Tensor & self, const Tensor & vec2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ger(self, vec2);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ger", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, vec2);
#endif
}

// aten::ger.out(Tensor self, Tensor vec2, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & ger_out(Tensor & out, const Tensor & self, const Tensor & vec2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ger_out_out(out, self, vec2);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ger", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, vec2);
#endif
}

// aten::group_norm(Tensor input, int num_groups, Tensor? weight=None, Tensor? bias=None, float eps=1e-05, bool cudnn_enabled=True) -> Tensor
static inline Tensor group_norm(const Tensor & input, int64_t num_groups, const Tensor & weight, const Tensor & bias, double eps, bool cudnn_enabled) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::group_norm(input, num_groups, weight, bias, eps, cudnn_enabled);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::group_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, const Tensor &, double, bool>(input, num_groups, weight, bias, eps, cudnn_enabled);
#endif
}

// aten::fft(Tensor self, int signal_ndim, bool normalized=False) -> Tensor
static inline Tensor fft(const Tensor & self, int64_t signal_ndim, bool normalized) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fft(self, signal_ndim, normalized);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fft", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool>(self, signal_ndim, normalized);
#endif
}

// aten::ifft(Tensor self, int signal_ndim, bool normalized=False) -> Tensor
static inline Tensor ifft(const Tensor & self, int64_t signal_ndim, bool normalized) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ifft(self, signal_ndim, normalized);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ifft", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool>(self, signal_ndim, normalized);
#endif
}

// aten::rfft(Tensor self, int signal_ndim, bool normalized=False, bool onesided=True) -> Tensor
static inline Tensor rfft(const Tensor & self, int64_t signal_ndim, bool normalized, bool onesided) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rfft(self, signal_ndim, normalized, onesided);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rfft", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool, bool>(self, signal_ndim, normalized, onesided);
#endif
}

// aten::irfft(Tensor self, int signal_ndim, bool normalized=False, bool onesided=True, int[] signal_sizes=[]) -> Tensor
static inline Tensor irfft(const Tensor & self, int64_t signal_ndim, bool normalized, bool onesided, IntArrayRef signal_sizes) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::irfft(self, signal_ndim, normalized, onesided, signal_sizes);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::irfft", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool, bool, IntArrayRef>(self, signal_ndim, normalized, onesided, signal_sizes);
#endif
}

// aten::_fft_with_size(Tensor self, int signal_ndim, bool complex_input, bool complex_output, bool inverse, int[] checked_signal_sizes, bool normalized, bool onesided, int[] output_sizes) -> Tensor
static inline Tensor _fft_with_size(const Tensor & self, int64_t signal_ndim, bool complex_input, bool complex_output, bool inverse, IntArrayRef checked_signal_sizes, bool normalized, bool onesided, IntArrayRef output_sizes) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_fft_with_size(self, signal_ndim, complex_input, complex_output, inverse, checked_signal_sizes, normalized, onesided, output_sizes);
            break;
        default:
            AT_ERROR("_fft_with_size not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_fft_with_size", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool, bool, bool, IntArrayRef, bool, bool, IntArrayRef>(self, signal_ndim, complex_input, complex_output, inverse, checked_signal_sizes, normalized, onesided, output_sizes);
#endif
}

// aten::_cufft_get_plan_cache_size(int device_index) -> int
static inline int64_t _cufft_get_plan_cache_size(int64_t device_index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cufft_get_plan_cache_size(device_index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cufft_get_plan_cache_size", "");
    return op.callUnboxed<int64_t, int64_t>(device_index);
#endif
}

// aten::_cufft_get_plan_cache_max_size(int device_index) -> int
static inline int64_t _cufft_get_plan_cache_max_size(int64_t device_index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cufft_get_plan_cache_max_size(device_index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cufft_get_plan_cache_max_size", "");
    return op.callUnboxed<int64_t, int64_t>(device_index);
#endif
}

// aten::_cufft_set_plan_cache_max_size(int device_index, int max_size) -> ()
static inline void _cufft_set_plan_cache_max_size(int64_t device_index, int64_t max_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
     TypeDefault::_cufft_set_plan_cache_max_size(device_index, max_size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cufft_set_plan_cache_max_size", "");
    return op.callUnboxed<void, int64_t, int64_t>(device_index, max_size);
#endif
}

// aten::_cufft_clear_plan_cache(int device_index) -> ()
static inline void _cufft_clear_plan_cache(int64_t device_index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
     TypeDefault::_cufft_clear_plan_cache(device_index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cufft_clear_plan_cache", "");
    return op.callUnboxed<void, int64_t>(device_index);
#endif
}

// aten::index.Tensor(Tensor self, Tensor?[] indices) -> Tensor
static inline Tensor index(const Tensor & self, TensorList indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_Tensor(self, indices);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, TensorList>(self, indices);
#endif
}

// aten::index_copy(Tensor self, int dim, Tensor index, Tensor source) -> Tensor
static inline Tensor index_copy(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & source) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_copy(self, dim, index, source);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_copy", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, const Tensor &>(self, dim, index, source);
#endif
}

// aten::index_copy.dimname(Tensor self, Dimname dim, Tensor index, Tensor source) -> Tensor
static inline Tensor index_copy(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & source) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_copy_dimname(self, dim, index, source);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_copy", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &, const Tensor &>(self, dim, index, source);
#endif
}

// aten::index_put_(Tensor(a!) self, Tensor?[] indices, Tensor values, bool accumulate=False) -> Tensor(a!)
static inline Tensor & index_put_(Tensor & self, TensorList indices, const Tensor & values, bool accumulate) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_put_(self, indices, values, accumulate);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_put_", "");
    return op.callUnboxed<Tensor &, Tensor &, TensorList, const Tensor &, bool>(self, indices, values, accumulate);
#endif
}

// aten::index_put(Tensor self, Tensor?[] indices, Tensor values, bool accumulate=False) -> Tensor
static inline Tensor index_put(const Tensor & self, TensorList indices, const Tensor & values, bool accumulate) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_put(self, indices, values, accumulate);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_put", "");
    return op.callUnboxed<Tensor, const Tensor &, TensorList, const Tensor &, bool>(self, indices, values, accumulate);
#endif
}

// aten::_index_put_impl_(Tensor(a!) self, Tensor?[] indices, Tensor values, bool accumulate=False, bool unsafe=False) -> Tensor(a!)
static inline Tensor & _index_put_impl_(Tensor & self, TensorList indices, const Tensor & values, bool accumulate, bool unsafe) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_index_put_impl_(self, indices, values, accumulate, unsafe);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_index_put_impl_", "");
    return op.callUnboxed<Tensor &, Tensor &, TensorList, const Tensor &, bool, bool>(self, indices, values, accumulate, unsafe);
#endif
}

// aten::instance_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool use_input_stats, float momentum, float eps, bool cudnn_enabled) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::instance_norm(input, weight, bias, running_mean, running_var, use_input_stats, momentum, eps, cudnn_enabled);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::instance_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, double, bool>(input, weight, bias, running_mean, running_var, use_input_stats, momentum, eps, cudnn_enabled);
#endif
}

// aten::inverse(Tensor self) -> Tensor
static inline Tensor inverse(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::inverse(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::inverse", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::inverse.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & inverse_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::inverse_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::inverse", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::_inverse_helper(Tensor self) -> Tensor
static inline Tensor _inverse_helper(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_inverse_helper(self);
            break;
        default:
            AT_ERROR("_inverse_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_inverse_helper", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::isclose(Tensor self, Tensor other, float rtol=1e-05, float atol=1e-08, bool equal_nan=False) -> Tensor
static inline Tensor isclose(const Tensor & self, const Tensor & other, double rtol, double atol, bool equal_nan) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::isclose(self, other, rtol, atol, equal_nan);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::isclose", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, double, double, bool>(self, other, rtol, atol, equal_nan);
#endif
}

// aten::isnan(Tensor self) -> Tensor
static inline Tensor isnan(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::isnan(self);
            break;
        default:
            AT_ERROR("isnan not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::isnan", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::is_distributed(Tensor self) -> bool
static inline bool is_distributed(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::is_distributed(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::is_distributed", "");
    return op.callUnboxed<bool, const Tensor &>(self);
#endif
}

// aten::is_floating_point(Tensor self) -> bool
static inline bool is_floating_point(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::is_floating_point(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::is_floating_point", "");
    return op.callUnboxed<bool, const Tensor &>(self);
#endif
}

// aten::is_complex(Tensor self) -> bool
static inline bool is_complex(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::is_complex(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::is_complex", "");
    return op.callUnboxed<bool, const Tensor &>(self);
#endif
}

// aten::is_nonzero(Tensor self) -> bool
static inline bool is_nonzero(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::is_nonzero(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::is_nonzero", "");
    return op.callUnboxed<bool, const Tensor &>(self);
#endif
}

// aten::is_same_size(Tensor self, Tensor other) -> bool
static inline bool is_same_size(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::is_same_size(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::is_same_size", "");
    return op.callUnboxed<bool, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::is_signed(Tensor self) -> bool
static inline bool is_signed(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::is_signed(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::is_signed", "");
    return op.callUnboxed<bool, const Tensor &>(self);
#endif
}

// aten::kl_div(Tensor self, Tensor target, int reduction=Mean, *, bool log_target=False) -> Tensor
static inline Tensor kl_div(const Tensor & self, const Tensor & target, int64_t reduction, bool log_target) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::kl_div(self, target, reduction, log_target);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::kl_div", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, bool>(self, target, reduction, log_target);
#endif
}

// aten::kl_div_backward(Tensor grad_output, Tensor self, Tensor target, int reduction=Mean, *, bool log_target=False) -> Tensor
static inline Tensor kl_div_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, bool log_target) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::kl_div_backward(grad_output, self, target, reduction, log_target);
            break;
        default:
            AT_ERROR("kl_div_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::kl_div_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t, bool>(grad_output, self, target, reduction, log_target);
#endif
}

// aten::kthvalue(Tensor self, int k, int dim=-1, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> kthvalue(const Tensor & self, int64_t k, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::kthvalue(self, k, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::kthvalue", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, int64_t, bool>(self, k, dim, keepdim);
#endif
}

// aten::kthvalue.values(Tensor self, int k, int dim=-1, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> kthvalue_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(values, indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::kthvalue_out_values(values, indices, self, k, dim, keepdim);
            break;
        default:
            AT_ERROR("kthvalue_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::kthvalue", "values");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, int64_t, bool>(values, indices, self, k, dim, keepdim);
#endif
}

// aten::kthvalue.dimname(Tensor self, int k, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> kthvalue(const Tensor & self, int64_t k, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::kthvalue_dimname(self, k, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::kthvalue", "dimname");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, Dimname, bool>(self, k, dim, keepdim);
#endif
}

// aten::kthvalue.dimname_out(Tensor self, int k, Dimname dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> kthvalue_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t k, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::kthvalue_out_dimname_out(values, indices, self, k, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::kthvalue", "dimname_out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, Dimname, bool>(values, indices, self, k, dim, keepdim);
#endif
}

// aten::layer_norm(Tensor input, int[] normalized_shape, Tensor? weight=None, Tensor? bias=None, float eps=1e-05, bool cudnn_enable=True) -> Tensor
static inline Tensor layer_norm(const Tensor & input, IntArrayRef normalized_shape, const Tensor & weight, const Tensor & bias, double eps, bool cudnn_enable) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::layer_norm(input, normalized_shape, weight, bias, eps, cudnn_enable);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::layer_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, const Tensor &, const Tensor &, double, bool>(input, normalized_shape, weight, bias, eps, cudnn_enable);
#endif
}

// aten::native_layer_norm(Tensor input, Tensor? weight, Tensor? bias, int M, int N, float eps) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> native_layer_norm(const Tensor & input, const Tensor & weight, const Tensor & bias, int64_t M, int64_t N, double eps) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::native_layer_norm(input, weight, bias, M, N, eps);
            break;
        default:
            AT_ERROR("native_layer_norm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::native_layer_norm", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, double>(input, weight, bias, M, N, eps);
#endif
}

// aten::native_layer_norm_backward(Tensor grad_out, Tensor input, Tensor mean, Tensor rstd, Tensor? weight, int M, int N, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> native_layer_norm_backward(const Tensor & grad_out, const Tensor & input, const Tensor & mean, const Tensor & rstd, const Tensor & weight, int64_t M, int64_t N, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_out, input, mean, rstd, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::native_layer_norm_backward(grad_out, input, mean, rstd, weight, M, N, output_mask);
            break;
        default:
            AT_ERROR("native_layer_norm_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::native_layer_norm_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, std::array<bool,3>>(grad_out, input, mean, rstd, weight, M, N, output_mask);
#endif
}

// aten::quantized_layer_norm(Tensor input, int[] normalized_shape, Tensor? weight, Tensor? bias, float eps, float output_scale, int output_zero_point) -> Tensor
static inline Tensor quantized_layer_norm(const Tensor & input, IntArrayRef normalized_shape, const Tensor & weight, const Tensor & bias, double eps, double output_scale, int64_t output_zero_point) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::quantized_layer_norm(input, normalized_shape, weight, bias, eps, output_scale, output_zero_point);
            break;
        default:
            AT_ERROR("quantized_layer_norm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_layer_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, const Tensor &, const Tensor &, double, double, int64_t>(input, normalized_shape, weight, bias, eps, output_scale, output_zero_point);
#endif
}

// aten::linear(Tensor input, Tensor weight, Tensor? bias=None) -> Tensor
static inline Tensor linear(const Tensor & input, const Tensor & weight, const Tensor & bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::linear(input, weight, bias);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::linear", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(input, weight, bias);
#endif
}

// aten::mkldnn_linear(Tensor input, Tensor weight, Tensor? bias=None) -> Tensor
static inline Tensor mkldnn_linear(const Tensor & input, const Tensor & weight, const Tensor & bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("mkldnn_linear not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mkldnn_linear", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(input, weight, bias);
#endif
}

// aten::fbgemm_linear_int8_weight_fp32_activation(Tensor input, Tensor weight, Tensor packed, Tensor col_offsets, Scalar weight_scale, Scalar weight_zero_point, Tensor bias) -> Tensor
static inline Tensor fbgemm_linear_int8_weight_fp32_activation(const Tensor & input, const Tensor & weight, const Tensor & packed, const Tensor & col_offsets, Scalar weight_scale, Scalar weight_zero_point, const Tensor & bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fbgemm_linear_int8_weight_fp32_activation(input, weight, packed, col_offsets, weight_scale, weight_zero_point, bias);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fbgemm_linear_int8_weight_fp32_activation", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, const Tensor &>(input, weight, packed, col_offsets, weight_scale, weight_zero_point, bias);
#endif
}

// aten::fbgemm_linear_int8_weight(Tensor input, Tensor weight, Tensor packed, Tensor col_offsets, Scalar weight_scale, Scalar weight_zero_point, Tensor bias) -> Tensor
static inline Tensor fbgemm_linear_int8_weight(const Tensor & input, const Tensor & weight, const Tensor & packed, const Tensor & col_offsets, Scalar weight_scale, Scalar weight_zero_point, const Tensor & bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fbgemm_linear_int8_weight(input, weight, packed, col_offsets, weight_scale, weight_zero_point, bias);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fbgemm_linear_int8_weight", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, const Tensor &>(input, weight, packed, col_offsets, weight_scale, weight_zero_point, bias);
#endif
}

// aten::fbgemm_linear_quantize_weight(Tensor input) -> (Tensor, Tensor, float, int)
static inline std::tuple<Tensor,Tensor,double,int64_t> fbgemm_linear_quantize_weight(const Tensor & input) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fbgemm_linear_quantize_weight(input);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fbgemm_linear_quantize_weight", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,double,int64_t>, const Tensor &>(input);
#endif
}

// aten::fbgemm_pack_gemm_matrix_fp16(Tensor input) -> Tensor
static inline Tensor fbgemm_pack_gemm_matrix_fp16(const Tensor & input) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fbgemm_pack_gemm_matrix_fp16(input);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fbgemm_pack_gemm_matrix_fp16", "");
    return op.callUnboxed<Tensor, const Tensor &>(input);
#endif
}

// aten::fbgemm_linear_fp16_weight_fp32_activation(Tensor input, Tensor packed_weight, Tensor bias) -> Tensor
static inline Tensor fbgemm_linear_fp16_weight_fp32_activation(const Tensor & input, const Tensor & packed_weight, const Tensor & bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fbgemm_linear_fp16_weight_fp32_activation(input, packed_weight, bias);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fbgemm_linear_fp16_weight_fp32_activation", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(input, packed_weight, bias);
#endif
}

// aten::fbgemm_linear_fp16_weight(Tensor input, Tensor packed_weight, Tensor bias) -> Tensor
static inline Tensor fbgemm_linear_fp16_weight(const Tensor & input, const Tensor & packed_weight, const Tensor & bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fbgemm_linear_fp16_weight(input, packed_weight, bias);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fbgemm_linear_fp16_weight", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(input, packed_weight, bias);
#endif
}

// aten::fbgemm_pack_quantized_matrix(Tensor input) -> Tensor
static inline Tensor fbgemm_pack_quantized_matrix(const Tensor & input) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fbgemm_pack_quantized_matrix(input);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fbgemm_pack_quantized_matrix", "");
    return op.callUnboxed<Tensor, const Tensor &>(input);
#endif
}

// aten::fbgemm_pack_quantized_matrix.KN(Tensor input, int K, int N) -> Tensor
static inline Tensor fbgemm_pack_quantized_matrix(const Tensor & input, int64_t K, int64_t N) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fbgemm_pack_quantized_matrix_KN(input, K, N);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fbgemm_pack_quantized_matrix", "KN");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t>(input, K, N);
#endif
}

// aten::linspace(Scalar start, Scalar end, int steps=100, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor linspace(Scalar start, Scalar end, int64_t steps, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::linspace(start, end, steps, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::linspace", "");
    return op.callUnboxed<Tensor, Scalar, Scalar, int64_t, const TensorOptions &>(start, end, steps, options);
#endif
}

// aten::linspace.out(Scalar start, Scalar end, int steps=100, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & linspace_out(Tensor & out, Scalar start, Scalar end, int64_t steps) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::linspace_out_out(out, start, end, steps);
            break;
        default:
            AT_ERROR("linspace_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::linspace", "out");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, Scalar, int64_t>(out, start, end, steps);
#endif
}

// aten::log(Tensor self) -> Tensor
static inline Tensor log(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::log_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & log_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::log.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & log_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log_out_out(out, self);
            break;
        default:
            AT_ERROR("log_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::log10(Tensor self) -> Tensor
static inline Tensor log10(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log10(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log10", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::log10_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & log10_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log10_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log10_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::log10.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & log10_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log10_out_out(out, self);
            break;
        default:
            AT_ERROR("log10_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log10", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::log1p(Tensor self) -> Tensor
static inline Tensor log1p(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log1p(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log1p", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::log1p_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & log1p_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log1p_(self);
            break;
        default:
            AT_ERROR("log1p_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log1p_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::log1p.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & log1p_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log1p_out_out(out, self);
            break;
        default:
            AT_ERROR("log1p_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log1p", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::log2(Tensor self) -> Tensor
static inline Tensor log2(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log2(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log2", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::log2_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & log2_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log2_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log2_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::log2.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & log2_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log2_out_out(out, self);
            break;
        default:
            AT_ERROR("log2_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log2", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::logdet(Tensor self) -> Tensor
static inline Tensor logdet(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logdet(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logdet", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::logspace(Scalar start, Scalar end, int steps=100, float base=10.0, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor logspace(Scalar start, Scalar end, int64_t steps, double base, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logspace(start, end, steps, base, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logspace", "");
    return op.callUnboxed<Tensor, Scalar, Scalar, int64_t, double, const TensorOptions &>(start, end, steps, base, options);
#endif
}

// aten::logspace.out(Scalar start, Scalar end, int steps=100, float base=10.0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & logspace_out(Tensor & out, Scalar start, Scalar end, int64_t steps, double base) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::logspace_out_out(out, start, end, steps, base);
            break;
        default:
            AT_ERROR("logspace_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logspace", "out");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, Scalar, int64_t, double>(out, start, end, steps, base);
#endif
}

// aten::log_softmax.int(Tensor self, int dim, ScalarType? dtype=None) -> Tensor
static inline Tensor log_softmax(const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log_softmax_int(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_softmax", "int");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, c10::optional<ScalarType>>(self, dim, dtype);
#endif
}

// aten::log_softmax.Dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor
static inline Tensor log_softmax(const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log_softmax_Dimname(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_softmax", "Dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, c10::optional<ScalarType>>(self, dim, dtype);
#endif
}

// aten::_log_softmax(Tensor self, int dim, bool half_to_float) -> Tensor
static inline Tensor _log_softmax(const Tensor & self, int64_t dim, bool half_to_float) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_log_softmax(self, dim, half_to_float);
            break;
        default:
            AT_ERROR("_log_softmax not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_log_softmax", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool>(self, dim, half_to_float);
#endif
}

// aten::_log_softmax_backward_data(Tensor grad_output, Tensor output, int dim, Tensor self) -> Tensor
static inline Tensor _log_softmax_backward_data(const Tensor & grad_output, const Tensor & output, int64_t dim, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_log_softmax_backward_data(grad_output, output, dim, self);
            break;
        default:
            AT_ERROR("_log_softmax_backward_data not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_log_softmax_backward_data", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, const Tensor &>(grad_output, output, dim, self);
#endif
}

// aten::logsumexp(Tensor self, int[1] dim, bool keepdim=False) -> Tensor
static inline Tensor logsumexp(const Tensor & self, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logsumexp(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logsumexp", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool>(self, dim, keepdim);
#endif
}

// aten::logsumexp.out(Tensor self, int[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & logsumexp_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logsumexp_out_out(out, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logsumexp", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool>(out, self, dim, keepdim);
#endif
}

// aten::logsumexp.names(Tensor self, Dimname[1] dim, bool keepdim=False) -> Tensor
static inline Tensor logsumexp(const Tensor & self, DimnameList dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logsumexp_names(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logsumexp", "names");
    return op.callUnboxed<Tensor, const Tensor &, DimnameList, bool>(self, dim, keepdim);
#endif
}

// aten::logsumexp.names_out(Tensor self, Dimname[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & logsumexp_out(Tensor & out, const Tensor & self, DimnameList dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::logsumexp_out_names_out(out, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::logsumexp", "names_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, DimnameList, bool>(out, self, dim, keepdim);
#endif
}

// aten::margin_ranking_loss(Tensor input1, Tensor input2, Tensor target, float margin=0.0, int reduction=Mean) -> Tensor
static inline Tensor margin_ranking_loss(const Tensor & input1, const Tensor & input2, const Tensor & target, double margin, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::margin_ranking_loss(input1, input2, target, margin, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::margin_ranking_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, double, int64_t>(input1, input2, target, margin, reduction);
#endif
}

// aten::matmul(Tensor self, Tensor other) -> Tensor
static inline Tensor matmul(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::matmul(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::matmul", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::matmul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & matmul_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::matmul_out_out(out, self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::matmul", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::matrix_rank.tol(Tensor self, float tol, bool symmetric=False) -> Tensor
static inline Tensor matrix_rank(const Tensor & self, double tol, bool symmetric) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::matrix_rank_tol(self, tol, symmetric);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::matrix_rank", "tol");
    return op.callUnboxed<Tensor, const Tensor &, double, bool>(self, tol, symmetric);
#endif
}

// aten::matrix_rank(Tensor self, bool symmetric=False) -> Tensor
static inline Tensor matrix_rank(const Tensor & self, bool symmetric) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::matrix_rank(self, symmetric);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::matrix_rank", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, symmetric);
#endif
}

// aten::matrix_power(Tensor self, int n) -> Tensor
static inline Tensor matrix_power(const Tensor & self, int64_t n) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::matrix_power(self, n);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::matrix_power", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, n);
#endif
}

// aten::max.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> max(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max", "dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::max.dim_max(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) max, Tensor(b!) max_values) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> max_out(Tensor & max, Tensor & max_values, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_out_dim_max(max, max_values, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max", "dim_max");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, bool>(max, max_values, self, dim, keepdim);
#endif
}

// aten::max_values(Tensor self, int[1] dim, bool keepdim=False) -> Tensor
static inline Tensor max_values(const Tensor & self, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_values(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_values", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool>(self, dim, keepdim);
#endif
}

// aten::max.names_dim(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> max(const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_names_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max", "names_dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, Dimname, bool>(self, dim, keepdim);
#endif
}

// aten::max.names_dim_max(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) max, Tensor(b!) max_values) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> max_out(Tensor & max, Tensor & max_values, const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_out_names_dim_max(max, max_values, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max", "names_dim_max");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, Dimname, bool>(max, max_values, self, dim, keepdim);
#endif
}

// aten::max_values.names(Tensor self, Dimname[1] dim, bool keepdim=False) -> Tensor
static inline Tensor max_values(const Tensor & self, DimnameList dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_values_names(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_values", "names");
    return op.callUnboxed<Tensor, const Tensor &, DimnameList, bool>(self, dim, keepdim);
#endif
}

// aten::max_pool1d_with_indices(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=0, int[1] dilation=1, bool ceil_mode=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> max_pool1d_with_indices(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_pool1d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool1d_with_indices", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::max_pool1d(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=0, int[1] dilation=1, bool ceil_mode=False) -> Tensor
static inline Tensor max_pool1d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_pool1d(self, kernel_size, stride, padding, dilation, ceil_mode);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool1d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::max_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> Tensor
static inline Tensor max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_pool2d(self, kernel_size, stride, padding, dilation, ceil_mode);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::mkldnn_max_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> Tensor
static inline Tensor mkldnn_max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("mkldnn_max_pool2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mkldnn_max_pool2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::quantized_max_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> Tensor
static inline Tensor quantized_max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::quantized_max_pool2d(self, kernel_size, stride, padding, dilation, ceil_mode);
            break;
        default:
            AT_ERROR("quantized_max_pool2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_max_pool2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::max_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> Tensor
static inline Tensor max_pool3d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_pool3d(self, kernel_size, stride, padding, dilation, ceil_mode);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool3d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::mean(Tensor self, *, ScalarType? dtype=None) -> Tensor
static inline Tensor mean(const Tensor & self, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mean(self, dtype);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::mean(self, dtype);
            break;
        default:
            AT_ERROR("mean not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mean", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<ScalarType>>(self, dtype);
#endif
}

// aten::mean.dim(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor
static inline Tensor mean(const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mean_dim(self, dim, keepdim, dtype);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::mean_dim(self, dim, keepdim, dtype);
            break;
        default:
            AT_ERROR("mean not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mean", "dim");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool, c10::optional<ScalarType>>(self, dim, keepdim, dtype);
#endif
}

// aten::mean.out(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & mean_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mean_out_out(out, self, dim, keepdim, dtype);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::mean_out_out(out, self, dim, keepdim, dtype);
            break;
        default:
            AT_ERROR("mean_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mean", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool, c10::optional<ScalarType>>(out, self, dim, keepdim, dtype);
#endif
}

// aten::mean.names_dim(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor
static inline Tensor mean(const Tensor & self, DimnameList dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mean_names_dim(self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mean", "names_dim");
    return op.callUnboxed<Tensor, const Tensor &, DimnameList, bool, c10::optional<ScalarType>>(self, dim, keepdim, dtype);
#endif
}

// aten::mean.names_out(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & mean_out(Tensor & out, const Tensor & self, DimnameList dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mean_out_names_out(out, self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mean", "names_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, DimnameList, bool, c10::optional<ScalarType>>(out, self, dim, keepdim, dtype);
#endif
}

// aten::median.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> median(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::median_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::median", "dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::median.dim_values(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> median_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::median_out_dim_values(values, indices, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::median", "dim_values");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, bool>(values, indices, self, dim, keepdim);
#endif
}

// aten::median.names_dim(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> median(const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::median_names_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::median", "names_dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, Dimname, bool>(self, dim, keepdim);
#endif
}

// aten::median.names_dim_values(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> median_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::median_out_names_dim_values(values, indices, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::median", "names_dim_values");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, Dimname, bool>(values, indices, self, dim, keepdim);
#endif
}

// aten::min.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> min(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::min_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min", "dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::min.dim_min(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) min, Tensor(b!) min_indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> min_out(Tensor & min, Tensor & min_indices, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::min_out_dim_min(min, min_indices, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min", "dim_min");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, bool>(min, min_indices, self, dim, keepdim);
#endif
}

// aten::min_values(Tensor self, int[1] dim, bool keepdim=False) -> Tensor
static inline Tensor min_values(const Tensor & self, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::min_values(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min_values", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool>(self, dim, keepdim);
#endif
}

// aten::min.names_dim(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> min(const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::min_names_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min", "names_dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, Dimname, bool>(self, dim, keepdim);
#endif
}

// aten::min.names_dim_min(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) min, Tensor(b!) min_indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> min_out(Tensor & min, Tensor & min_indices, const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::min_out_names_dim_min(min, min_indices, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min", "names_dim_min");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, Dimname, bool>(min, min_indices, self, dim, keepdim);
#endif
}

// aten::min_values.names(Tensor self, Dimname[1] dim, bool keepdim=False) -> Tensor
static inline Tensor min_values(const Tensor & self, DimnameList dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::min_values_names(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min_values", "names");
    return op.callUnboxed<Tensor, const Tensor &, DimnameList, bool>(self, dim, keepdim);
#endif
}

// aten::mkldnn_convolution(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] stride, int[] dilation, int groups) -> Tensor
static inline Tensor mkldnn_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mkldnn_convolution(self, weight, bias, padding, stride, dilation, groups);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mkldnn_convolution", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t>(self, weight, bias, padding, stride, dilation, groups);
#endif
}

// aten::mkldnn_convolution_backward_input(int[] self_size, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool bias_defined) -> Tensor
static inline Tensor mkldnn_convolution_backward_input(IntArrayRef self_size, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool bias_defined) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mkldnn_convolution_backward_input(self_size, grad_output, weight, padding, stride, dilation, groups, bias_defined);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mkldnn_convolution_backward_input", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool>(self_size, grad_output, weight, padding, stride, dilation, groups, bias_defined);
#endif
}

// aten::mkldnn_convolution_backward_weights(int[] weight_size, Tensor grad_output, Tensor self, int[] padding, int[] stride, int[] dilation, int groups, bool bias_defined) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> mkldnn_convolution_backward_weights(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool bias_defined) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mkldnn_convolution_backward_weights(weight_size, grad_output, self, padding, stride, dilation, groups, bias_defined);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mkldnn_convolution_backward_weights", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool>(weight_size, grad_output, self, padding, stride, dilation, groups, bias_defined);
#endif
}

// aten::mkldnn_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> mkldnn_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mkldnn_convolution_backward(self, grad_output, weight, padding, stride, dilation, groups, output_mask);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mkldnn_convolution_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, std::array<bool,3>>(self, grad_output, weight, padding, stride, dilation, groups, output_mask);
#endif
}

// aten::miopen_batch_norm(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon) -> (Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, bias, running_mean, running_var);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_batch_norm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_batch_norm", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, double>(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon);
#endif
}

// aten::miopen_batch_norm_backward(Tensor input, Tensor grad_output, Tensor weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var, float epsilon) -> (Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, grad_output, weight, running_mean, running_var, save_mean, save_var);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_batch_norm_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_batch_norm_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, double>(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon);
#endif
}

// aten::miopen_convolution(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_convolution_backward_input(int[] self_size, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_convolution_backward_input(IntArrayRef self_size, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution_backward_input not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution_backward_input", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self_size, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> miopen_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool, std::array<bool,3>>(self, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic, output_mask);
#endif
}

// aten::miopen_convolution_backward_bias(Tensor grad_output) -> Tensor
static inline Tensor miopen_convolution_backward_bias(const Tensor & grad_output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution_backward_bias not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution_backward_bias", "");
    return op.callUnboxed<Tensor, const Tensor &>(grad_output);
#endif
}

// aten::miopen_convolution_backward_weight(int[] weight_size, Tensor grad_output, Tensor self, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_convolution_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution_backward_weight not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution_backward_weight", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_convolution_transpose(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_convolution_transpose(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution_transpose not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution_transpose", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_convolution_transpose_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> miopen_convolution_transpose_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution_transpose_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution_transpose_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool, std::array<bool,3>>(self, grad_output, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, output_mask);
#endif
}

// aten::miopen_convolution_transpose_backward_input(Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_convolution_transpose_backward_input(const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution_transpose_backward_input not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution_transpose_backward_input", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_convolution_transpose_backward_weight(int[] weight_size, Tensor grad_output, Tensor self, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_convolution_transpose_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_convolution_transpose_backward_weight not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_convolution_transpose_backward_weight", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_depthwise_convolution(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_depthwise_convolution(const Tensor & self, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_depthwise_convolution not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_depthwise_convolution", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_depthwise_convolution_backward_input(int[] self_size, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_depthwise_convolution_backward_input(IntArrayRef self_size, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_depthwise_convolution_backward_input not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_depthwise_convolution_backward_input", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(self_size, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_depthwise_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> miopen_depthwise_convolution_backward(const Tensor & self, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, grad_output, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_depthwise_convolution_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_depthwise_convolution_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool, std::array<bool,3>>(self, grad_output, weight, padding, stride, dilation, groups, benchmark, deterministic, output_mask);
#endif
}

// aten::miopen_depthwise_convolution_backward_weight(int[] weight_size, Tensor grad_output, Tensor self, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor
static inline Tensor miopen_depthwise_convolution_backward_weight(IntArrayRef weight_size, const Tensor & grad_output, const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_depthwise_convolution_backward_weight not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_depthwise_convolution_backward_weight", "");
    return op.callUnboxed<Tensor, IntArrayRef, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t, bool, bool>(weight_size, grad_output, self, padding, stride, dilation, groups, benchmark, deterministic);
#endif
}

// aten::miopen_rnn(Tensor input, Tensor[] weight, int weight_stride0, Tensor hx, Tensor? cx, int mode, int hidden_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> miopen_rnn(const Tensor & input, TensorList weight, int64_t weight_stride0, 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, IntArrayRef batch_sizes, const Tensor & dropout_state) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, hx, cx, dropout_state);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_rnn not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_rnn", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor>, const Tensor &, TensorList, int64_t, const Tensor &, const Tensor &, int64_t, int64_t, int64_t, bool, double, bool, bool, IntArrayRef, const Tensor &>(input, weight, weight_stride0, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state);
#endif
}

// aten::miopen_rnn_backward(Tensor input, Tensor[] weight, int weight_stride0, Tensor weight_buf, Tensor hx, Tensor? cx, Tensor output, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, int mode, int hidden_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state, Tensor reserve, bool[4] output_mask) -> (Tensor, Tensor, Tensor, Tensor[])
static inline std::tuple<Tensor,Tensor,Tensor,std::vector<Tensor>> miopen_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, IntArrayRef batch_sizes, const Tensor & dropout_state, const Tensor & reserve, std::array<bool,4> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, dropout_state, reserve);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("miopen_rnn_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::miopen_rnn_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,std::vector<Tensor>>, const Tensor &, TensorList, int64_t, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, int64_t, bool, double, bool, bool, IntArrayRef, const Tensor &, const Tensor &, std::array<bool,4>>(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);
#endif
}

// aten::mm(Tensor self, Tensor mat2) -> Tensor
static inline Tensor mm(const Tensor & self, const Tensor & mat2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mm(self, mat2);
            break;
        default:
            AT_ERROR("mm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, mat2);
#endif
}

// aten::mm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & mm_out(Tensor & out, const Tensor & self, const Tensor & mat2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mm_out_out(out, self, mat2);
            break;
        default:
            AT_ERROR("mm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, mat2);
#endif
}

// aten::_sparse_mm(Tensor sparse, Tensor dense) -> Tensor
static inline Tensor _sparse_mm(const Tensor & sparse, const Tensor & dense) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sparse_mm(sparse, dense);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_mm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(sparse, dense);
#endif
}

// aten::mode(Tensor self, int dim=-1, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> mode(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mode(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mode", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::mode.values(Tensor self, int dim=-1, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> mode_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mode_out_values(values, indices, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mode", "values");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, bool>(values, indices, self, dim, keepdim);
#endif
}

// aten::mode.dimname(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> mode(const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mode_dimname(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mode", "dimname");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, Dimname, bool>(self, dim, keepdim);
#endif
}

// aten::mode.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> mode_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mode_out_dimname_out(values, indices, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mode", "dimname_out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, Dimname, bool>(values, indices, self, dim, keepdim);
#endif
}

// aten::mul.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor mul(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mul_Tensor(self, other);
            break;
        default:
            AT_ERROR("mul not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mul", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::mul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & mul_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mul_out_out(out, self, other);
            break;
        default:
            AT_ERROR("mul_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mul", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::mul.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor mul(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mul_Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mul", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::mv(Tensor self, Tensor vec) -> Tensor
static inline Tensor mv(const Tensor & self, const Tensor & vec) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, vec);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mv(self, vec);
            break;
        default:
            AT_ERROR("mv not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mv", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, vec);
#endif
}

// aten::mv.out(Tensor self, Tensor vec, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & mv_out(Tensor & out, const Tensor & self, const Tensor & vec) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, vec);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mv_out_out(out, self, vec);
            break;
        default:
            AT_ERROR("mv_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mv", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, vec);
#endif
}

// aten::mvlgamma(Tensor self, int p) -> Tensor
static inline Tensor mvlgamma(const Tensor & self, int64_t p) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mvlgamma(self, p);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mvlgamma", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, p);
#endif
}

// aten::narrow(Tensor(a) self, int dim, int start, int length) -> Tensor(a)
static inline Tensor narrow(const Tensor & self, int64_t dim, int64_t start, int64_t length) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::narrow(self, dim, start, length);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::narrow", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t, int64_t>(self, dim, start, length);
#endif
}

// aten::narrow.Tensor(Tensor(a) self, int dim, Tensor start, int length) -> Tensor(a)
static inline Tensor narrow(const Tensor & self, int64_t dim, const Tensor & start, int64_t length) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::narrow_Tensor(self, dim, start, length);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::narrow", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, int64_t>(self, dim, start, length);
#endif
}

// aten::native_batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, bias, running_mean, running_var);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::native_batch_norm(input, weight, bias, running_mean, running_var, training, momentum, eps);
            break;
        default:
            AT_ERROR("native_batch_norm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::native_batch_norm", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, double>(input, weight, bias, running_mean, running_var, training, momentum, eps);
#endif
}

// aten::native_batch_norm.out(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!))
static inline std::tuple<Tensor &,Tensor &,Tensor &> native_batch_norm_out(Tensor & out, Tensor & save_mean, Tensor & save_invstd, const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & running_mean, const Tensor & running_var, bool training, double momentum, double eps) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, save_mean, save_invstd, input, weight, bias, running_mean, running_var);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("native_batch_norm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::native_batch_norm", "out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &,Tensor &>, Tensor &, Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, double>(out, save_mean, save_invstd, input, weight, bias, running_mean, running_var, training, momentum, eps);
#endif
}

// aten::batch_norm_stats(Tensor input, float eps) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> batch_norm_stats(const Tensor & input, double eps) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("batch_norm_stats not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm_stats", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, double>(input, eps);
#endif
}

// aten::batch_norm_elemt(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor invstd, float eps) -> Tensor
static inline Tensor batch_norm_elemt(const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & mean, const Tensor & invstd, double eps) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, weight, bias, mean, invstd);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("batch_norm_elemt not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm_elemt", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, double>(input, weight, bias, mean, invstd, eps);
#endif
}

// aten::batch_norm_elemt.out(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor invstd, float eps, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & batch_norm_elemt_out(Tensor & out, const Tensor & input, const Tensor & weight, const Tensor & bias, const Tensor & mean, const Tensor & invstd, double eps) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, input, weight, bias, mean, invstd);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("batch_norm_elemt_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm_elemt", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, double>(out, input, weight, bias, mean, invstd, eps);
#endif
}

// aten::batch_norm_gather_stats(Tensor input, Tensor mean, Tensor invstd, Tensor? running_mean, Tensor? running_var, float momentum, float eps, int count) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> batch_norm_gather_stats(const Tensor & input, const Tensor & mean, const Tensor & invstd, const Tensor & running_mean, const Tensor & running_var, double momentum, double eps, int64_t count) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, mean, invstd, running_mean, running_var);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("batch_norm_gather_stats not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm_gather_stats", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, double, double, int64_t>(input, mean, invstd, running_mean, running_var, momentum, eps, count);
#endif
}

// aten::batch_norm_gather_stats_with_counts(Tensor input, Tensor mean, Tensor invstd, Tensor? running_mean, Tensor? running_var, float momentum, float eps, Tensor counts) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> batch_norm_gather_stats_with_counts(const Tensor & input, const Tensor & mean, const Tensor & invstd, const Tensor & running_mean, const Tensor & running_var, double momentum, double eps, const Tensor & counts) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, mean, invstd, running_mean, running_var, counts);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("batch_norm_gather_stats_with_counts not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm_gather_stats_with_counts", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, double, double, const Tensor &>(input, mean, invstd, running_mean, running_var, momentum, eps, counts);
#endif
}

// aten::native_batch_norm_backward(Tensor grad_out, Tensor input, Tensor? weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_invstd, bool train, float eps, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_out, input, weight, running_mean, running_var, save_mean, save_invstd);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::native_batch_norm_backward(grad_out, input, weight, running_mean, running_var, save_mean, save_invstd, train, eps, output_mask);
            break;
        default:
            AT_ERROR("native_batch_norm_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::native_batch_norm_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, double, std::array<bool,3>>(grad_out, input, weight, running_mean, running_var, save_mean, save_invstd, train, eps, output_mask);
#endif
}

// aten::batch_norm_backward_reduce(Tensor grad_out, Tensor input, Tensor mean, Tensor invstd, Tensor? weight, bool input_g, bool weight_g, bool bias_g) -> (Tensor, Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor,Tensor> batch_norm_backward_reduce(const Tensor & grad_out, const Tensor & input, const Tensor & mean, const Tensor & invstd, const Tensor & weight, bool input_g, bool weight_g, bool bias_g) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_out, input, mean, invstd, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("batch_norm_backward_reduce not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm_backward_reduce", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, bool, bool>(grad_out, input, mean, invstd, weight, input_g, weight_g, bias_g);
#endif
}

// aten::batch_norm_backward_elemt(Tensor grad_out, Tensor input, Tensor mean, Tensor invstd, Tensor? weight, Tensor mean_dy, Tensor mean_dy_xmu) -> Tensor
static inline Tensor batch_norm_backward_elemt(const Tensor & grad_out, const Tensor & input, const Tensor & mean, const Tensor & invstd, const Tensor & weight, const Tensor & mean_dy, const Tensor & mean_dy_xmu) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_out, input, mean, invstd, weight, mean_dy, mean_dy_xmu);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("batch_norm_backward_elemt not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm_backward_elemt", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(grad_out, input, mean, invstd, weight, mean_dy, mean_dy_xmu);
#endif
}

// aten::batch_norm_update_stats(Tensor input, Tensor? running_mean, Tensor? running_var, float momentum) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> batch_norm_update_stats(const Tensor & input, const Tensor & running_mean, const Tensor & running_var, double momentum) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input, running_mean, running_var);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::batch_norm_update_stats(input, running_mean, running_var, momentum);
            break;
        default:
            AT_ERROR("batch_norm_update_stats not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::batch_norm_update_stats", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, double>(input, running_mean, running_var, momentum);
#endif
}

// aten::_nnpack_available() -> bool
static inline bool _nnpack_available() {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_nnpack_available();
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_nnpack_available", "");
    return op.callUnboxed<bool>();
#endif
}

// aten::_nnpack_spatial_convolution(Tensor input, Tensor weight, Tensor? bias, int[2] padding, int[2] stride=1) -> Tensor
static inline Tensor _nnpack_spatial_convolution(const Tensor & input, const Tensor & weight, const Tensor & bias, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_nnpack_spatial_convolution(input, weight, bias, padding, stride);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_nnpack_spatial_convolution", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef>(input, weight, bias, padding, stride);
#endif
}

// aten::_nnpack_spatial_convolution_backward(Tensor input, Tensor grad_output, Tensor weight, int[2] padding, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> _nnpack_spatial_convolution_backward(const Tensor & input, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_nnpack_spatial_convolution_backward(input, grad_output, weight, padding, output_mask);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_nnpack_spatial_convolution_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, std::array<bool,3>>(input, grad_output, weight, padding, output_mask);
#endif
}

// aten::_nnpack_spatial_convolution_backward_input(Tensor input, Tensor grad_output, Tensor weight, int[2] padding) -> Tensor
static inline Tensor _nnpack_spatial_convolution_backward_input(const Tensor & input, const Tensor & grad_output, const Tensor & weight, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_nnpack_spatial_convolution_backward_input(input, grad_output, weight, padding);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_nnpack_spatial_convolution_backward_input", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef>(input, grad_output, weight, padding);
#endif
}

// aten::_nnpack_spatial_convolution_backward_weight(Tensor input, int[] weightsize, Tensor grad_output, int[2] padding) -> Tensor
static inline Tensor _nnpack_spatial_convolution_backward_weight(const Tensor & input, IntArrayRef weightsize, const Tensor & grad_output, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_nnpack_spatial_convolution_backward_weight(input, weightsize, grad_output, padding);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_nnpack_spatial_convolution_backward_weight", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef>(input, weightsize, grad_output, padding);
#endif
}

// aten::ones.names(int[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor ones(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ones_names(size, names, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ones", "names");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<DimnameList>, const TensorOptions &>(size, names, options);
#endif
}

// aten::ones(int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor ones(IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ones(size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ones", "");
    return op.callUnboxed<Tensor, IntArrayRef, const TensorOptions &>(size, options);
#endif
}

// aten::ones.out(int[] size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & ones_out(Tensor & out, IntArrayRef size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ones_out_out(out, size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ones", "out");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef>(out, size);
#endif
}

// aten::ones_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor ones_like(const Tensor & self, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::ones_like(self, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ones_like", "");
    return op.callUnboxed<Tensor, const Tensor &, const TensorOptions &, c10::optional<MemoryFormat>>(self, options, memory_format);
#endif
}

// aten::pairwise_distance(Tensor x1, Tensor x2, float p=2, float eps=1e-06, bool keepdim=False) -> Tensor
static inline Tensor pairwise_distance(const Tensor & x1, const Tensor & x2, double p, double eps, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::pairwise_distance(x1, x2, p, eps, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pairwise_distance", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, double, double, bool>(x1, x2, p, eps, keepdim);
#endif
}

// aten::cdist(Tensor x1, Tensor x2, float p=2, int? compute_mode=None) -> Tensor
static inline Tensor cdist(const Tensor & x1, const Tensor & x2, double p, c10::optional<int64_t> compute_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cdist(x1, x2, p, compute_mode);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cdist", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, double, c10::optional<int64_t>>(x1, x2, p, compute_mode);
#endif
}

// aten::_cdist_forward(Tensor x1, Tensor x2, float p, int? compute_mode) -> Tensor
static inline Tensor _cdist_forward(const Tensor & x1, const Tensor & x2, double p, c10::optional<int64_t> compute_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cdist_forward(x1, x2, p, compute_mode);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cdist_forward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, double, c10::optional<int64_t>>(x1, x2, p, compute_mode);
#endif
}

// aten::_cdist_backward(Tensor grad, Tensor x1, Tensor x2, float p, Tensor cdist) -> Tensor
static inline Tensor _cdist_backward(const Tensor & grad, const Tensor & x1, const Tensor & x2, double p, const Tensor & cdist) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_cdist_backward(grad, x1, x2, p, cdist);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cdist_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, double, const Tensor &>(grad, x1, x2, p, cdist);
#endif
}

// aten::pdist(Tensor self, float p=2) -> Tensor
static inline Tensor pdist(const Tensor & self, double p) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::pdist(self, p);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pdist", "");
    return op.callUnboxed<Tensor, const Tensor &, double>(self, p);
#endif
}

// aten::_pdist_forward(Tensor self, float p=2) -> Tensor
static inline Tensor _pdist_forward(const Tensor & self, double p) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_pdist_forward(self, p);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_pdist_forward", "");
    return op.callUnboxed<Tensor, const Tensor &, double>(self, p);
#endif
}

// aten::_pdist_backward(Tensor grad, Tensor self, float p, Tensor pdist) -> Tensor
static inline Tensor _pdist_backward(const Tensor & grad, const Tensor & self, double p, const Tensor & pdist) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_pdist_backward(grad, self, p, pdist);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_pdist_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, double, const Tensor &>(grad, self, p, pdist);
#endif
}

// aten::cosine_similarity(Tensor x1, Tensor x2, int dim=1, float eps=1e-08) -> Tensor
static inline Tensor cosine_similarity(const Tensor & x1, const Tensor & x2, int64_t dim, double eps) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cosine_similarity(x1, x2, dim, eps);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cosine_similarity", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, double>(x1, x2, dim, eps);
#endif
}

// aten::pixel_shuffle(Tensor self, int upscale_factor) -> Tensor
static inline Tensor pixel_shuffle(const Tensor & self, int64_t upscale_factor) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::pixel_shuffle(self, upscale_factor);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pixel_shuffle", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, upscale_factor);
#endif
}

// aten::pinverse(Tensor self, float rcond=1e-15) -> Tensor
static inline Tensor pinverse(const Tensor & self, double rcond) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::pinverse(self, rcond);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pinverse", "");
    return op.callUnboxed<Tensor, const Tensor &, double>(self, rcond);
#endif
}

// aten::poisson_nll_loss(Tensor input, Tensor target, bool log_input, bool full, float eps, int reduction) -> Tensor
static inline Tensor poisson_nll_loss(const Tensor & input, const Tensor & target, bool log_input, bool full, double eps, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::poisson_nll_loss(input, target, log_input, full, eps, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::poisson_nll_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, bool, bool, double, int64_t>(input, target, log_input, full, eps, reduction);
#endif
}

// aten::scalar_tensor(Scalar s, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor scalar_tensor(Scalar s, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::scalar_tensor(s, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::scalar_tensor", "");
    return op.callUnboxed<Tensor, Scalar, const TensorOptions &>(s, options);
#endif
}

// aten::rand.names(int[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor rand(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rand_names(size, names, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rand", "names");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<DimnameList>, const TensorOptions &>(size, names, options);
#endif
}

// aten::rand.generator_with_names(int[] size, *, Generator? generator, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor rand(IntArrayRef size, c10::optional<Generator> generator, c10::optional<DimnameList> names, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rand_generator_with_names(size, generator, names, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rand", "generator_with_names");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<Generator>, c10::optional<DimnameList>, const TensorOptions &>(size, generator, names, options);
#endif
}

// aten::rand(int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor rand(IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rand(size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rand", "");
    return op.callUnboxed<Tensor, IntArrayRef, const TensorOptions &>(size, options);
#endif
}

// aten::rand.generator(int[] size, *, Generator? generator, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor rand(IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rand_generator(size, generator, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rand", "generator");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<Generator>, const TensorOptions &>(size, generator, options);
#endif
}

// aten::rand.out(int[] size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & rand_out(Tensor & out, IntArrayRef size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rand_out_out(out, size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rand", "out");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef>(out, size);
#endif
}

// aten::rand.generator_out(int[] size, *, Generator? generator, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & rand_out(Tensor & out, IntArrayRef size, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rand_out_generator_out(out, size, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rand", "generator_out");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef, c10::optional<Generator>>(out, size, generator);
#endif
}

// aten::rand_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor rand_like(const Tensor & self, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rand_like(self, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rand_like", "");
    return op.callUnboxed<Tensor, const Tensor &, const TensorOptions &, c10::optional<MemoryFormat>>(self, options, memory_format);
#endif
}

// aten::randint(int high, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randint(int64_t high, IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint(high, size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint", "");
    return op.callUnboxed<Tensor, int64_t, IntArrayRef, const TensorOptions &>(high, size, options);
#endif
}

// aten::randint.generator(int high, int[] size, *, Generator? generator, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randint(int64_t high, IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_generator(high, size, generator, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint", "generator");
    return op.callUnboxed<Tensor, int64_t, IntArrayRef, c10::optional<Generator>, const TensorOptions &>(high, size, generator, options);
#endif
}

// aten::randint.low(int low, int high, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randint(int64_t low, int64_t high, IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_low(low, high, size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint", "low");
    return op.callUnboxed<Tensor, int64_t, int64_t, IntArrayRef, const TensorOptions &>(low, high, size, options);
#endif
}

// aten::randint.low_generator(int low, int high, int[] size, *, Generator? generator, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randint(int64_t low, int64_t high, IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_low_generator(low, high, size, generator, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint", "low_generator");
    return op.callUnboxed<Tensor, int64_t, int64_t, IntArrayRef, c10::optional<Generator>, const TensorOptions &>(low, high, size, generator, options);
#endif
}

// aten::randint.out(int high, int[] size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & randint_out(Tensor & out, int64_t high, IntArrayRef size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_out_out(out, high, size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint", "out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, IntArrayRef>(out, high, size);
#endif
}

// aten::randint.generator_out(int high, int[] size, *, Generator? generator, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & randint_out(Tensor & out, int64_t high, IntArrayRef size, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_out_generator_out(out, high, size, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint", "generator_out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, IntArrayRef, c10::optional<Generator>>(out, high, size, generator);
#endif
}

// aten::randint.low_out(int low, int high, int[] size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & randint_out(Tensor & out, int64_t low, int64_t high, IntArrayRef size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_out_low_out(out, low, high, size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint", "low_out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, int64_t, IntArrayRef>(out, low, high, size);
#endif
}

// aten::randint.low_generator_out(int low, int high, int[] size, *, Generator? generator, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & randint_out(Tensor & out, int64_t low, int64_t high, IntArrayRef size, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_out_low_generator_out(out, low, high, size, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint", "low_generator_out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, int64_t, IntArrayRef, c10::optional<Generator>>(out, low, high, size, generator);
#endif
}

// aten::randint_like(Tensor self, int high, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor randint_like(const Tensor & self, int64_t high, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_like(self, high, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint_like", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const TensorOptions &, c10::optional<MemoryFormat>>(self, high, options, memory_format);
#endif
}

// aten::randint_like.low_dtype(Tensor self, int low, int high, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor randint_like(const Tensor & self, int64_t low, int64_t high, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randint_like_low_dtype(self, low, high, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randint_like", "low_dtype");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t, const TensorOptions &, c10::optional<MemoryFormat>>(self, low, high, options, memory_format);
#endif
}

// aten::randn(int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randn(IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randn(size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randn", "");
    return op.callUnboxed<Tensor, IntArrayRef, const TensorOptions &>(size, options);
#endif
}

// aten::randn.generator(int[] size, *, Generator? generator, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randn(IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randn_generator(size, generator, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randn", "generator");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<Generator>, const TensorOptions &>(size, generator, options);
#endif
}

// aten::randn.names(int[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randn(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randn_names(size, names, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randn", "names");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<DimnameList>, const TensorOptions &>(size, names, options);
#endif
}

// aten::randn.generator_with_names(int[] size, *, Generator? generator, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randn(IntArrayRef size, c10::optional<Generator> generator, c10::optional<DimnameList> names, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randn_generator_with_names(size, generator, names, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randn", "generator_with_names");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<Generator>, c10::optional<DimnameList>, const TensorOptions &>(size, generator, names, options);
#endif
}

// aten::randn.out(int[] size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & randn_out(Tensor & out, IntArrayRef size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randn_out_out(out, size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randn", "out");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef>(out, size);
#endif
}

// aten::randn.generator_out(int[] size, *, Generator? generator, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & randn_out(Tensor & out, IntArrayRef size, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randn_out_generator_out(out, size, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randn", "generator_out");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef, c10::optional<Generator>>(out, size, generator);
#endif
}

// aten::randn_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor randn_like(const Tensor & self, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randn_like(self, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randn_like", "");
    return op.callUnboxed<Tensor, const Tensor &, const TensorOptions &, c10::optional<MemoryFormat>>(self, options, memory_format);
#endif
}

// aten::randperm(int n, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randperm(int64_t n, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randperm(n, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randperm", "");
    return op.callUnboxed<Tensor, int64_t, const TensorOptions &>(n, options);
#endif
}

// aten::randperm.generator(int n, *, Generator? generator, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor randperm(int64_t n, c10::optional<Generator> generator, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randperm_generator(n, generator, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randperm", "generator");
    return op.callUnboxed<Tensor, int64_t, c10::optional<Generator>, const TensorOptions &>(n, generator, options);
#endif
}

// aten::randperm.out(int n, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & randperm_out(Tensor & out, int64_t n) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::randperm_out_out(out, n);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randperm", "out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t>(out, n);
#endif
}

// aten::randperm.generator_out(int n, *, Generator? generator, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & randperm_out(Tensor & out, int64_t n, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::randperm_out_generator_out(out, n, generator);
            break;
        default:
            AT_ERROR("randperm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::randperm", "generator_out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, c10::optional<Generator>>(out, n, generator);
#endif
}

// aten::range.step(Scalar start, Scalar end, Scalar step=1, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor range(Scalar start, Scalar end, Scalar step, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::range_step(start, end, step, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::range", "step");
    return op.callUnboxed<Tensor, Scalar, Scalar, Scalar, const TensorOptions &>(start, end, step, options);
#endif
}

// aten::range(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor range(Scalar start, Scalar end, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::range(start, end, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::range", "");
    return op.callUnboxed<Tensor, Scalar, Scalar, const TensorOptions &>(start, end, options);
#endif
}

// aten::range.out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & range_out(Tensor & out, Scalar start, Scalar end, Scalar step) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::range_out_out(out, start, end, step);
            break;
        default:
            AT_ERROR("range_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::range", "out");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, Scalar, Scalar>(out, start, end, step);
#endif
}

// aten::reciprocal(Tensor self) -> Tensor
static inline Tensor reciprocal(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::reciprocal(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reciprocal", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::reciprocal_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & reciprocal_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::reciprocal_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reciprocal_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::reciprocal.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & reciprocal_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::reciprocal_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reciprocal", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::neg(Tensor self) -> Tensor
static inline Tensor neg(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::neg(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::neg", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::neg_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & neg_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::neg_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::neg_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::neg.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & neg_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::neg_out_out(out, self);
            break;
        default:
            AT_ERROR("neg_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::neg", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::repeat_interleave.Tensor(Tensor repeats) -> Tensor
static inline Tensor repeat_interleave(const Tensor & repeats) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(repeats);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::repeat_interleave_Tensor(repeats);
            break;
        default:
            AT_ERROR("repeat_interleave not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::repeat_interleave", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &>(repeats);
#endif
}

// aten::repeat_interleave.self_Tensor(Tensor self, Tensor repeats, int? dim=None) -> Tensor
static inline Tensor repeat_interleave(const Tensor & self, const Tensor & repeats, c10::optional<int64_t> dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::repeat_interleave_self_Tensor(self, repeats, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::repeat_interleave", "self_Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, c10::optional<int64_t>>(self, repeats, dim);
#endif
}

// aten::repeat_interleave.self_int(Tensor self, int repeats, int? dim=None) -> Tensor
static inline Tensor repeat_interleave(const Tensor & self, int64_t repeats, c10::optional<int64_t> dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::repeat_interleave_self_int(self, repeats, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::repeat_interleave", "self_int");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, c10::optional<int64_t>>(self, repeats, dim);
#endif
}

// aten::reshape(Tensor self, int[] shape) -> Tensor
static inline Tensor reshape(const Tensor & self, IntArrayRef shape) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::reshape(self, shape);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reshape", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, shape);
#endif
}

// aten::_mkldnn_reshape(Tensor self, int[] shape) -> Tensor
static inline Tensor _mkldnn_reshape(const Tensor & self, IntArrayRef shape) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_mkldnn_reshape not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_mkldnn_reshape", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, shape);
#endif
}

// aten::round(Tensor self) -> Tensor
static inline Tensor round(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::round(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::round", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::round_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & round_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::round_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::round_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::round.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & round_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::round_out_out(out, self);
            break;
        default:
            AT_ERROR("round_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::round", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::rrelu(Tensor self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None) -> Tensor
static inline Tensor rrelu(const Tensor & self, Scalar lower, Scalar upper, bool training, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rrelu(self, lower, upper, training, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rrelu", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar, bool, c10::optional<Generator>>(self, lower, upper, training, generator);
#endif
}

// aten::rrelu_(Tensor(a!) self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None) -> Tensor(a!)
static inline Tensor & rrelu_(Tensor & self, Scalar lower, Scalar upper, bool training, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rrelu_(self, lower, upper, training, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rrelu_", "");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, Scalar, bool, c10::optional<Generator>>(self, lower, upper, training, generator);
#endif
}

// aten::relu(Tensor self) -> Tensor
static inline Tensor relu(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::relu(self);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::relu(self);
            break;
        default:
            AT_ERROR("relu not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::relu", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::relu_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & relu_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::relu_(self);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::relu_(self);
            break;
        default:
            AT_ERROR("relu_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::relu_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::prelu(Tensor self, Tensor weight) -> Tensor
static inline Tensor prelu(const Tensor & self, const Tensor & weight) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::prelu(self, weight);
            break;
        default:
            AT_ERROR("prelu not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::prelu", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, weight);
#endif
}

// aten::prelu_backward(Tensor grad_output, Tensor self, Tensor weight) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> prelu_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::prelu_backward(grad_output, self, weight);
            break;
        default:
            AT_ERROR("prelu_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::prelu_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &>(grad_output, self, weight);
#endif
}

// aten::gelu(Tensor self) -> Tensor
static inline Tensor gelu(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::gelu(self);
            break;
        default:
            AT_ERROR("gelu not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gelu", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::gelu_backward(Tensor grad, Tensor self) -> Tensor
static inline Tensor gelu_backward(const Tensor & grad, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::gelu_backward(grad, self);
            break;
        default:
            AT_ERROR("gelu_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gelu_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad, self);
#endif
}

// aten::hardshrink(Tensor self, Scalar lambd=0.5) -> Tensor
static inline Tensor hardshrink(const Tensor & self, Scalar lambd) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hardshrink(self, lambd);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardshrink", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, lambd);
#endif
}

// aten::hardshrink_backward(Tensor grad_out, Tensor self, Scalar lambd) -> Tensor
static inline Tensor hardshrink_backward(const Tensor & grad_out, const Tensor & self, Scalar lambd) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hardshrink_backward(grad_out, self, lambd);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardshrink_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(grad_out, self, lambd);
#endif
}

// aten::rsqrt(Tensor self) -> Tensor
static inline Tensor rsqrt(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rsqrt(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rsqrt", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::rsqrt_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & rsqrt_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rsqrt_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rsqrt_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::rsqrt.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & rsqrt_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::rsqrt_out_out(out, self);
            break;
        default:
            AT_ERROR("rsqrt_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rsqrt", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::select.Dimname(Tensor(a) self, Dimname dim, int index) -> Tensor(a)
static inline Tensor select(const Tensor & self, Dimname dim, int64_t index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::select_Dimname(self, dim, index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::select", "Dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, int64_t>(self, dim, index);
#endif
}

// aten::select.int(Tensor(a) self, int dim, int index) -> Tensor(a)
static inline Tensor select(const Tensor & self, int64_t dim, int64_t index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::select_int(self, dim, index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::select", "int");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t>(self, dim, index);
#endif
}

// aten::selu(Tensor self) -> Tensor
static inline Tensor selu(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::selu(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::selu", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::selu_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & selu_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::selu_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::selu_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::celu(Tensor self, Scalar alpha=1.0) -> Tensor
static inline Tensor celu(const Tensor & self, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::celu(self, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::celu", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, alpha);
#endif
}

// aten::celu_(Tensor(a!) self, Scalar alpha=1.0) -> Tensor(a!)
static inline Tensor & celu_(Tensor & self, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::celu_(self, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::celu_", "");
    return op.callUnboxed<Tensor &, Tensor &, Scalar>(self, alpha);
#endif
}

// aten::sigmoid(Tensor self) -> Tensor
static inline Tensor sigmoid(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sigmoid(self);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::sigmoid(self);
            break;
        default:
            AT_ERROR("sigmoid not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sigmoid", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::sigmoid_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & sigmoid_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sigmoid_(self);
            break;
        default:
            AT_ERROR("sigmoid_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sigmoid_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::sigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sigmoid_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sigmoid_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sigmoid", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::sin(Tensor self) -> Tensor
static inline Tensor sin(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sin(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sin", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::sin_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & sin_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sin_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sin_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::sin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sin_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sin_out_out(out, self);
            break;
        default:
            AT_ERROR("sin_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sin", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::sinh(Tensor self) -> Tensor
static inline Tensor sinh(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sinh(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sinh", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::sinh_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & sinh_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sinh_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sinh_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::sinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sinh_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sinh_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sinh", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::detach(Tensor self) -> Tensor
static inline Tensor detach(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::detach(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::detach", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::detach_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & detach_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::detach_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::detach_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::size.int(Tensor self, int dim) -> int
static inline int64_t size(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::size_int(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::size", "int");
    return op.callUnboxed<int64_t, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::size.Dimname(Tensor self, Dimname dim) -> int
static inline int64_t size(const Tensor & self, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::size_Dimname(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::size", "Dimname");
    return op.callUnboxed<int64_t, const Tensor &, Dimname>(self, dim);
#endif
}

// aten::slice.Tensor(Tensor(a) self, int dim=0, int start=0, int end=9223372036854775807, int step=1) -> Tensor(a)
static inline Tensor slice(const Tensor & self, int64_t dim, int64_t start, int64_t end, int64_t step) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::slice_Tensor(self, dim, start, end, step);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slice", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t, int64_t, int64_t>(self, dim, start, end, step);
#endif
}

// aten::slogdet(Tensor self) -> (Tensor sign, Tensor logabsdet)
static inline std::tuple<Tensor,Tensor> slogdet(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::slogdet(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slogdet", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &>(self);
#endif
}

// aten::smm(Tensor self, Tensor mat2) -> Tensor
static inline Tensor smm(const Tensor & self, const Tensor & mat2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::smm(self, mat2);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::smm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, mat2);
#endif
}

// aten::softmax.int(Tensor self, int dim, ScalarType? dtype=None) -> Tensor
static inline Tensor softmax(const Tensor & self, int64_t dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::softmax_int(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softmax", "int");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, c10::optional<ScalarType>>(self, dim, dtype);
#endif
}

// aten::softmax.Dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor
static inline Tensor softmax(const Tensor & self, Dimname dim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::softmax_Dimname(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softmax", "Dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, c10::optional<ScalarType>>(self, dim, dtype);
#endif
}

// aten::_softmax(Tensor self, int dim, bool half_to_float) -> Tensor
static inline Tensor _softmax(const Tensor & self, int64_t dim, bool half_to_float) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_softmax(self, dim, half_to_float);
            break;
        default:
            AT_ERROR("_softmax not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_softmax", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool>(self, dim, half_to_float);
#endif
}

// aten::_softmax_backward_data(Tensor grad_output, Tensor output, int dim, Tensor self) -> Tensor
static inline Tensor _softmax_backward_data(const Tensor & grad_output, const Tensor & output, int64_t dim, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_softmax_backward_data(grad_output, output, dim, self);
            break;
        default:
            AT_ERROR("_softmax_backward_data not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_softmax_backward_data", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, const Tensor &>(grad_output, output, dim, self);
#endif
}

// aten::split.Tensor(Tensor(a) self, int split_size, int dim=0) -> Tensor(a)[]
static inline std::vector<Tensor> split(const Tensor & self, int64_t split_size, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::split_Tensor(self, split_size, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::split", "Tensor");
    return op.callUnboxed<std::vector<Tensor>, const Tensor &, int64_t, int64_t>(self, split_size, dim);
#endif
}

// aten::split_with_sizes(Tensor self, int[] split_sizes, int dim=0) -> Tensor[]
static inline std::vector<Tensor> split_with_sizes(const Tensor & self, IntArrayRef split_sizes, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::split_with_sizes(self, split_sizes, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::split_with_sizes", "");
    return op.callUnboxed<std::vector<Tensor>, const Tensor &, IntArrayRef, int64_t>(self, split_sizes, dim);
#endif
}

// aten::squeeze(Tensor(a) self) -> Tensor(a)
static inline Tensor squeeze(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::squeeze(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::squeeze", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::squeeze.dim(Tensor(a) self, int dim) -> Tensor(a)
static inline Tensor squeeze(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::squeeze_dim(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::squeeze", "dim");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::squeeze.dimname(Tensor(a) self, Dimname dim) -> Tensor(a)
static inline Tensor squeeze(const Tensor & self, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::squeeze_dimname(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::squeeze", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname>(self, dim);
#endif
}

// aten::sspaddmm(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
static inline Tensor sspaddmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sspaddmm(self, mat1, mat2, beta, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sspaddmm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, mat1, mat2, beta, alpha);
#endif
}

// aten::sspaddmm.out(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sspaddmm_out(Tensor & out, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, mat1, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sspaddmm_out_out(out, self, mat1, mat2, beta, alpha);
            break;
        default:
            AT_ERROR("sspaddmm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sspaddmm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(out, self, mat1, mat2, beta, alpha);
#endif
}

// aten::stack(Tensor[] tensors, int dim=0) -> Tensor
static inline Tensor stack(TensorList tensors, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::stack(tensors, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::stack", "");
    return op.callUnboxed<Tensor, TensorList, int64_t>(tensors, dim);
#endif
}

// aten::stack.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & stack_out(Tensor & out, TensorList tensors, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::stack_out_out(out, tensors, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::stack", "out");
    return op.callUnboxed<Tensor &, Tensor &, TensorList, int64_t>(out, tensors, dim);
#endif
}

// aten::stft(Tensor self, int n_fft, int? hop_length=None, int? win_length=None, Tensor? window=None, bool normalized=False, bool onesided=True) -> Tensor
static inline Tensor stft(const Tensor & self, int64_t n_fft, c10::optional<int64_t> hop_length, c10::optional<int64_t> win_length, const Tensor & window, bool normalized, bool onesided) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::stft(self, n_fft, hop_length, win_length, window, normalized, onesided);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::stft", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, c10::optional<int64_t>, c10::optional<int64_t>, const Tensor &, bool, bool>(self, n_fft, hop_length, win_length, window, normalized, onesided);
#endif
}

// aten::istft(Tensor self, int n_fft, int? hop_length=None, int? win_length=None, Tensor? window=None, bool center=True, bool normalized=False, bool onesided=True, int? length=None) -> Tensor
static inline Tensor istft(const Tensor & self, int64_t n_fft, c10::optional<int64_t> hop_length, c10::optional<int64_t> win_length, const Tensor & window, bool center, bool normalized, bool onesided, c10::optional<int64_t> length) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::istft(self, n_fft, hop_length, win_length, window, center, normalized, onesided, length);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::istft", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, c10::optional<int64_t>, c10::optional<int64_t>, const Tensor &, bool, bool, bool, c10::optional<int64_t>>(self, n_fft, hop_length, win_length, window, center, normalized, onesided, length);
#endif
}

// aten::stride.int(Tensor self, int dim) -> int
static inline int64_t stride(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::stride_int(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::stride", "int");
    return op.callUnboxed<int64_t, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::stride.Dimname(Tensor self, Dimname dim) -> int
static inline int64_t stride(const Tensor & self, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::stride_Dimname(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::stride", "Dimname");
    return op.callUnboxed<int64_t, const Tensor &, Dimname>(self, dim);
#endif
}

// aten::sum(Tensor self, *, ScalarType? dtype=None) -> Tensor
static inline Tensor sum(const Tensor & self, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sum(self, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sum", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<ScalarType>>(self, dtype);
#endif
}

// aten::sum.dim_IntList(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor
static inline Tensor sum(const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sum_dim_IntList(self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sum", "dim_IntList");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool, c10::optional<ScalarType>>(self, dim, keepdim, dtype);
#endif
}

// aten::sum.dim_DimnameList(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor
static inline Tensor sum(const Tensor & self, DimnameList dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sum_dim_DimnameList(self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sum", "dim_DimnameList");
    return op.callUnboxed<Tensor, const Tensor &, DimnameList, bool, c10::optional<ScalarType>>(self, dim, keepdim, dtype);
#endif
}

// aten::sum.IntList_out(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sum_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sum_out_IntList_out(out, self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sum", "IntList_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool, c10::optional<ScalarType>>(out, self, dim, keepdim, dtype);
#endif
}

// aten::sum.DimnameList_out(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sum_out(Tensor & out, const Tensor & self, DimnameList dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sum_out_DimnameList_out(out, self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sum", "DimnameList_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, DimnameList, bool, c10::optional<ScalarType>>(out, self, dim, keepdim, dtype);
#endif
}

// aten::sqrt(Tensor self) -> Tensor
static inline Tensor sqrt(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sqrt(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sqrt", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::sqrt_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & sqrt_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sqrt_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sqrt_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::sqrt.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sqrt_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sqrt_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sqrt", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::square(Tensor self) -> Tensor
static inline Tensor square(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::square(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::square", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::square_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & square_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::square_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::square_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::std(Tensor self, bool unbiased=True) -> Tensor
static inline Tensor std(const Tensor & self, bool unbiased) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::std(self, unbiased);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::std", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, unbiased);
#endif
}

// aten::std.dim(Tensor self, int[1] dim, bool unbiased=True, bool keepdim=False) -> Tensor
static inline Tensor std(const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::std_dim(self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::std", "dim");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool, bool>(self, dim, unbiased, keepdim);
#endif
}

// aten::std_mean(Tensor self, bool unbiased=True) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> std_mean(const Tensor & self, bool unbiased) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::std_mean(self, unbiased);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::std_mean", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, bool>(self, unbiased);
#endif
}

// aten::std_mean.dim(Tensor self, int[1] dim, bool unbiased=True, bool keepdim=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> std_mean(const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::std_mean_dim(self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::std_mean", "dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef, bool, bool>(self, dim, unbiased, keepdim);
#endif
}

// aten::std_mean.names_dim(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> std_mean(const Tensor & self, DimnameList dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::std_mean_names_dim(self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::std_mean", "names_dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, DimnameList, bool, bool>(self, dim, unbiased, keepdim);
#endif
}

// aten::std.out(Tensor self, int[1] dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & std_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::std_out_out(out, self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::std", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool, bool>(out, self, dim, unbiased, keepdim);
#endif
}

// aten::std.names_dim(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False) -> Tensor
static inline Tensor std(const Tensor & self, DimnameList dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::std_names_dim(self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::std", "names_dim");
    return op.callUnboxed<Tensor, const Tensor &, DimnameList, bool, bool>(self, dim, unbiased, keepdim);
#endif
}

// aten::std.names_out(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & std_out(Tensor & out, const Tensor & self, DimnameList dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::std_out_names_out(out, self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::std", "names_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, DimnameList, bool, bool>(out, self, dim, unbiased, keepdim);
#endif
}

// aten::prod(Tensor self, *, ScalarType? dtype=None) -> Tensor
static inline Tensor prod(const Tensor & self, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::prod(self, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::prod", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<ScalarType>>(self, dtype);
#endif
}

// aten::prod.dim_int(Tensor self, int dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor
static inline Tensor prod(const Tensor & self, int64_t dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::prod_dim_int(self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::prod", "dim_int");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool, c10::optional<ScalarType>>(self, dim, keepdim, dtype);
#endif
}

// aten::prod.int_out(Tensor self, int dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & prod_out(Tensor & out, const Tensor & self, int64_t dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::prod_out_int_out(out, self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::prod", "int_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, bool, c10::optional<ScalarType>>(out, self, dim, keepdim, dtype);
#endif
}

// aten::prod.dim_Dimname(Tensor self, Dimname dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor
static inline Tensor prod(const Tensor & self, Dimname dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::prod_dim_Dimname(self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::prod", "dim_Dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, bool, c10::optional<ScalarType>>(self, dim, keepdim, dtype);
#endif
}

// aten::prod.Dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & prod_out(Tensor & out, const Tensor & self, Dimname dim, bool keepdim, c10::optional<ScalarType> dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::prod_out_Dimname_out(out, self, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::prod", "Dimname_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Dimname, bool, c10::optional<ScalarType>>(out, self, dim, keepdim, dtype);
#endif
}

// aten::t(Tensor(a) self) -> Tensor(a)
static inline Tensor t(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::t(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::t", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::tan(Tensor self) -> Tensor
static inline Tensor tan(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::tan(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tan", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::tan_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & tan_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::tan_(self);
            break;
        default:
            AT_ERROR("tan_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tan_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::tan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & tan_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::tan_out_out(out, self);
            break;
        default:
            AT_ERROR("tan_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tan", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::tanh(Tensor self) -> Tensor
static inline Tensor tanh(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::tanh(self);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::tanh(self);
            break;
        default:
            AT_ERROR("tanh not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tanh", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::tanh_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & tanh_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::tanh_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tanh_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::tanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & tanh_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::tanh_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tanh", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::tensordot(Tensor self, Tensor other, int[] dims_self, int[] dims_other) -> Tensor
static inline Tensor tensordot(const Tensor & self, const Tensor & other, IntArrayRef dims_self, IntArrayRef dims_other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::tensordot(self, other, dims_self, dims_other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tensordot", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef>(self, other, dims_self, dims_other);
#endif
}

// aten::threshold(Tensor self, Scalar threshold, Scalar value) -> Tensor
static inline Tensor threshold(const Tensor & self, Scalar threshold, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::threshold(self, threshold, value);
            break;
        default:
            AT_ERROR("threshold not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::threshold", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar>(self, threshold, value);
#endif
}

// aten::threshold_(Tensor(a!) self, Scalar threshold, Scalar value) -> Tensor(a!)
static inline Tensor & threshold_(Tensor & self, Scalar threshold, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::threshold_(self, threshold, value);
            break;
        default:
            AT_ERROR("threshold_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::threshold_", "");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, Scalar>(self, threshold, value);
#endif
}

// aten::threshold.out(Tensor self, Scalar threshold, Scalar value, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & threshold_out(Tensor & out, const Tensor & self, Scalar threshold, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::threshold_out_out(out, self, threshold, value);
            break;
        default:
            AT_ERROR("threshold_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::threshold", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar, Scalar>(out, self, threshold, value);
#endif
}

// aten::threshold_backward(Tensor grad_output, Tensor self, Scalar threshold) -> Tensor
static inline Tensor threshold_backward(const Tensor & grad_output, const Tensor & self, Scalar threshold) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::threshold_backward(grad_output, self, threshold);
            break;
        default:
            AT_ERROR("threshold_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::threshold_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(grad_output, self, threshold);
#endif
}

// aten::transpose.int(Tensor(a) self, int dim0, int dim1) -> Tensor(a)
static inline Tensor transpose(const Tensor & self, int64_t dim0, int64_t dim1) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::transpose_int(self, dim0, dim1);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::transpose", "int");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t>(self, dim0, dim1);
#endif
}

// aten::transpose.Dimname(Tensor(a) self, Dimname dim0, Dimname dim1) -> Tensor(a)
static inline Tensor transpose(const Tensor & self, Dimname dim0, Dimname dim1) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::transpose_Dimname(self, dim0, dim1);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::transpose", "Dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, Dimname>(self, dim0, dim1);
#endif
}

// aten::_mkldnn_transpose(Tensor self, int dim0, int dim1) -> Tensor
static inline Tensor _mkldnn_transpose(const Tensor & self, int64_t dim0, int64_t dim1) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_mkldnn_transpose not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_mkldnn_transpose", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t>(self, dim0, dim1);
#endif
}

// aten::_mkldnn_transpose_(Tensor(a!) self, int dim0, int dim1) -> Tensor(a!)
static inline Tensor & _mkldnn_transpose_(Tensor & self, int64_t dim0, int64_t dim1) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_mkldnn_transpose_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_mkldnn_transpose_", "");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, int64_t>(self, dim0, dim1);
#endif
}

// aten::one_hot(Tensor self, int num_classes=-1) -> Tensor
static inline Tensor one_hot(const Tensor & self, int64_t num_classes) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::one_hot(self, num_classes);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::one_hot", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, num_classes);
#endif
}

// aten::flip(Tensor self, int[] dims) -> Tensor
static inline Tensor flip(const Tensor & self, IntArrayRef dims) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::flip(self, dims);
            break;
        default:
            AT_ERROR("flip not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::flip", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, dims);
#endif
}

// aten::roll(Tensor self, int[1] shifts, int[1] dims=[]) -> Tensor
static inline Tensor roll(const Tensor & self, IntArrayRef shifts, IntArrayRef dims) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::roll(self, shifts, dims);
            break;
        default:
            AT_ERROR("roll not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::roll", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef>(self, shifts, dims);
#endif
}

// aten::rot90(Tensor self, int k=1, int[] dims=[0,1]) -> Tensor
static inline Tensor rot90(const Tensor & self, int64_t k, IntArrayRef dims) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rot90(self, k, dims);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rot90", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, IntArrayRef>(self, k, dims);
#endif
}

// aten::trapz.x(Tensor y, Tensor x, *, int dim=-1) -> Tensor
static inline Tensor trapz(const Tensor & y, const Tensor & x, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::trapz_x(y, x, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::trapz", "x");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(y, x, dim);
#endif
}

// aten::trapz.dx(Tensor y, *, float dx=1, int dim=-1) -> Tensor
static inline Tensor trapz(const Tensor & y, double dx, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::trapz_dx(y, dx, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::trapz", "dx");
    return op.callUnboxed<Tensor, const Tensor &, double, int64_t>(y, dx, dim);
#endif
}

// aten::_trilinear(Tensor i1, Tensor i2, Tensor i3, int[] expand1, int[] expand2, int[] expand3, int[] sumdim, int unroll_dim=1) -> Tensor
static inline Tensor _trilinear(const Tensor & i1, const Tensor & i2, const Tensor & i3, IntArrayRef expand1, IntArrayRef expand2, IntArrayRef expand3, IntArrayRef sumdim, int64_t unroll_dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_trilinear(i1, i2, i3, expand1, expand2, expand3, sumdim, unroll_dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_trilinear", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, int64_t>(i1, i2, i3, expand1, expand2, expand3, sumdim, unroll_dim);
#endif
}

// aten::triplet_margin_loss(Tensor anchor, Tensor positive, Tensor negative, float margin=1.0, float p=2, float eps=1e-06, bool swap=False, int reduction=Mean) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::triplet_margin_loss(anchor, positive, negative, margin, p, eps, swap, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::triplet_margin_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, double, double, double, bool, int64_t>(anchor, positive, negative, margin, p, eps, swap, reduction);
#endif
}

// aten::true_divide.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor true_divide(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::true_divide_Tensor(self, other);
            break;
        default:
            AT_ERROR("true_divide not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::true_divide", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::true_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & true_divide_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::true_divide_out_out(out, self, other);
            break;
        default:
            AT_ERROR("true_divide_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::true_divide", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::true_divide.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor true_divide(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::true_divide_Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::true_divide", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::trunc(Tensor self) -> Tensor
static inline Tensor trunc(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::trunc(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::trunc", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::trunc_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & trunc_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::trunc_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::trunc_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::trunc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & trunc_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::trunc_out_out(out, self);
            break;
        default:
            AT_ERROR("trunc_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::trunc", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::_has_compatible_shallow_copy_type(Tensor self, Tensor from) -> bool
static inline bool _has_compatible_shallow_copy_type(const Tensor & self, const Tensor & from) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_has_compatible_shallow_copy_type(self, from);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_has_compatible_shallow_copy_type", "");
    return op.callUnboxed<bool, const Tensor &, const Tensor &>(self, from);
#endif
}

// aten::_unique(Tensor self, bool sorted=True, bool return_inverse=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _unique(const Tensor & self, bool sorted, bool return_inverse) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_unique(self, sorted, return_inverse);
            break;
        default:
            AT_ERROR("_unique not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_unique", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, bool, bool>(self, sorted, return_inverse);
#endif
}

// aten::unique_dim(Tensor self, int dim, bool sorted=True, bool return_inverse=False, bool return_counts=False) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> unique_dim(const Tensor & self, int64_t dim, bool sorted, bool return_inverse, bool return_counts) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::unique_dim(self, dim, sorted, return_inverse, return_counts);
            break;
        default:
            AT_ERROR("unique_dim not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::unique_dim", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, int64_t, bool, bool, bool>(self, dim, sorted, return_inverse, return_counts);
#endif
}

// aten::unique_consecutive(Tensor self, bool return_inverse=False, bool return_counts=False, int? dim=None) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> unique_consecutive(const Tensor & self, bool return_inverse, bool return_counts, c10::optional<int64_t> dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::unique_consecutive(self, return_inverse, return_counts, dim);
            break;
        default:
            AT_ERROR("unique_consecutive not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::unique_consecutive", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, bool, bool, c10::optional<int64_t>>(self, return_inverse, return_counts, dim);
#endif
}

// aten::unique_dim_consecutive(Tensor self, int dim, bool return_inverse=False, bool return_counts=False) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> unique_dim_consecutive(const Tensor & self, int64_t dim, bool return_inverse, bool return_counts) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::unique_dim_consecutive(self, dim, return_inverse, return_counts);
            break;
        default:
            AT_ERROR("unique_dim_consecutive not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::unique_dim_consecutive", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, int64_t, bool, bool>(self, dim, return_inverse, return_counts);
#endif
}

// aten::_unique2(Tensor self, bool sorted=True, bool return_inverse=False, bool return_counts=False) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> _unique2(const Tensor & self, bool sorted, bool return_inverse, bool return_counts) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_unique2(self, sorted, return_inverse, return_counts);
            break;
        default:
            AT_ERROR("_unique2 not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_unique2", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, bool, bool, bool>(self, sorted, return_inverse, return_counts);
#endif
}

// aten::_unsafe_view(Tensor self, int[] size) -> Tensor
static inline Tensor _unsafe_view(const Tensor & self, IntArrayRef size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_unsafe_view(self, size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_unsafe_view", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, size);
#endif
}

// aten::unsqueeze(Tensor(a) self, int dim) -> Tensor(a)
static inline Tensor unsqueeze(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::unsqueeze(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::unsqueeze", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::var(Tensor self, bool unbiased=True) -> Tensor
static inline Tensor var(const Tensor & self, bool unbiased) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::var(self, unbiased);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::var", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, unbiased);
#endif
}

// aten::var.dim(Tensor self, int[1] dim, bool unbiased=True, bool keepdim=False) -> Tensor
static inline Tensor var(const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::var_dim(self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::var", "dim");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool, bool>(self, dim, unbiased, keepdim);
#endif
}

// aten::var.out(Tensor self, int[1] dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & var_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::var_out_out(out, self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::var", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool, bool>(out, self, dim, unbiased, keepdim);
#endif
}

// aten::var.names_dim(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False) -> Tensor
static inline Tensor var(const Tensor & self, DimnameList dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::var_names_dim(self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::var", "names_dim");
    return op.callUnboxed<Tensor, const Tensor &, DimnameList, bool, bool>(self, dim, unbiased, keepdim);
#endif
}

// aten::var.names_out(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & var_out(Tensor & out, const Tensor & self, DimnameList dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::var_out_names_out(out, self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::var", "names_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, DimnameList, bool, bool>(out, self, dim, unbiased, keepdim);
#endif
}

// aten::var_mean(Tensor self, bool unbiased=True) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> var_mean(const Tensor & self, bool unbiased) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::var_mean(self, unbiased);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::var_mean", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, bool>(self, unbiased);
#endif
}

// aten::var_mean.dim(Tensor self, int[1] dim, bool unbiased=True, bool keepdim=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> var_mean(const Tensor & self, IntArrayRef dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::var_mean_dim(self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::var_mean", "dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef, bool, bool>(self, dim, unbiased, keepdim);
#endif
}

// aten::var_mean.names_dim(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> var_mean(const Tensor & self, DimnameList dim, bool unbiased, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::var_mean_names_dim(self, dim, unbiased, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::var_mean", "names_dim");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, DimnameList, bool, bool>(self, dim, unbiased, keepdim);
#endif
}

// aten::where.self(Tensor condition, Tensor self, Tensor other) -> Tensor
static inline Tensor where(const Tensor & condition, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::where_self(condition, self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::where", "self");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(condition, self, other);
#endif
}

// aten::where(Tensor condition) -> Tensor[]
static inline std::vector<Tensor> where(const Tensor & condition) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::where(condition);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::where", "");
    return op.callUnboxed<std::vector<Tensor>, const Tensor &>(condition);
#endif
}

// aten::_s_where(Tensor condition, Tensor self, Tensor other) -> Tensor
static inline Tensor _s_where(const Tensor & condition, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_s_where(condition, self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_s_where", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(condition, self, other);
#endif
}

// aten::norm_except_dim(Tensor v, int pow=2, int dim=0) -> Tensor
static inline Tensor norm_except_dim(const Tensor & v, int64_t pow, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_except_dim(v, pow, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm_except_dim", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, int64_t>(v, pow, dim);
#endif
}

// aten::_weight_norm(Tensor v, Tensor g, int dim=0) -> Tensor
static inline Tensor _weight_norm(const Tensor & v, const Tensor & g, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_weight_norm(v, g, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_weight_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(v, g, dim);
#endif
}

// aten::_weight_norm_cuda_interface(Tensor v, Tensor g, int dim=0) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _weight_norm_cuda_interface(const Tensor & v, const Tensor & g, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(v, g);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_weight_norm_cuda_interface not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_weight_norm_cuda_interface", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, int64_t>(v, g, dim);
#endif
}

// aten::_weight_norm_cuda_interface_backward(Tensor grad_w, Tensor saved_v, Tensor saved_g, Tensor saved_norms, int dim) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_w, saved_v, saved_g, saved_norms);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_weight_norm_cuda_interface_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_weight_norm_cuda_interface_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_w, saved_v, saved_g, saved_norms, dim);
#endif
}

// aten::_weight_norm_differentiable_backward(Tensor grad_w, Tensor saved_v, Tensor saved_g, Tensor saved_norms, int dim) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_weight_norm_differentiable_backward(grad_w, saved_v, saved_g, saved_norms, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_weight_norm_differentiable_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_w, saved_v, saved_g, saved_norms, dim);
#endif
}

// aten::zeros.names(int[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor zeros(IntArrayRef size, c10::optional<DimnameList> names, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::zeros_names(size, names, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::zeros", "names");
    return op.callUnboxed<Tensor, IntArrayRef, c10::optional<DimnameList>, const TensorOptions &>(size, names, options);
#endif
}

// aten::zeros(int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor zeros(IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::zeros(size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::zeros", "");
    return op.callUnboxed<Tensor, IntArrayRef, const TensorOptions &>(size, options);
#endif
}

// aten::zeros.out(int[] size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & zeros_out(Tensor & out, IntArrayRef size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::zeros_out_out(out, size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::zeros", "out");
    return op.callUnboxed<Tensor &, Tensor &, IntArrayRef>(out, size);
#endif
}

// aten::zeros_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor zeros_like(const Tensor & self, const TensorOptions & options, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::zeros_like(self, options, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::zeros_like", "");
    return op.callUnboxed<Tensor, const Tensor &, const TensorOptions &, c10::optional<MemoryFormat>>(self, options, memory_format);
#endif
}

// aten::_standard_gamma_grad(Tensor self, Tensor output) -> Tensor
static inline Tensor _standard_gamma_grad(const Tensor & self, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_standard_gamma_grad(self, output);
            break;
        default:
            AT_ERROR("_standard_gamma_grad not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_standard_gamma_grad", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, output);
#endif
}

// aten::_standard_gamma(Tensor self, Generator? generator=None) -> Tensor
static inline Tensor _standard_gamma(const Tensor & self, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_standard_gamma(self, generator);
            break;
        default:
            AT_ERROR("_standard_gamma not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_standard_gamma", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Generator>>(self, generator);
#endif
}

// aten::_dirichlet_grad(Tensor x, Tensor alpha, Tensor total) -> Tensor
static inline Tensor _dirichlet_grad(const Tensor & x, const Tensor & alpha, const Tensor & total) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(x, alpha, total);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_dirichlet_grad(x, alpha, total);
            break;
        default:
            AT_ERROR("_dirichlet_grad not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_dirichlet_grad", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(x, alpha, total);
#endif
}

// aten::_sample_dirichlet(Tensor self, Generator? generator=None) -> Tensor
static inline Tensor _sample_dirichlet(const Tensor & self, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_sample_dirichlet(self, generator);
            break;
        default:
            AT_ERROR("_sample_dirichlet not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sample_dirichlet", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Generator>>(self, generator);
#endif
}

// aten::poisson(Tensor self, Generator? generator=None) -> Tensor
static inline Tensor poisson(const Tensor & self, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::poisson(self, generator);
            break;
        default:
            AT_ERROR("poisson not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::poisson", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Generator>>(self, generator);
#endif
}

// aten::binomial(Tensor count, Tensor prob, Generator? generator=None) -> Tensor
static inline Tensor binomial(const Tensor & count, const Tensor & prob, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(count, prob);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::binomial(count, prob, generator);
            break;
        default:
            AT_ERROR("binomial not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::binomial", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, c10::optional<Generator>>(count, prob, generator);
#endif
}

// aten::native_norm(Tensor self, Scalar p=2) -> Tensor
static inline Tensor native_norm(const Tensor & self, Scalar p) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("native_norm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::native_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, p);
#endif
}

// aten::_sparse_sum(Tensor self) -> Tensor
static inline Tensor _sparse_sum(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sparse_sum(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_sum", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::_sparse_sum.dtype(Tensor self, *, ScalarType dtype) -> Tensor
static inline Tensor _sparse_sum(const Tensor & self, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sparse_sum_dtype(self, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_sum", "dtype");
    return op.callUnboxed<Tensor, const Tensor &, ScalarType>(self, dtype);
#endif
}

// aten::_sparse_sum.dim(Tensor self, int[1] dim) -> Tensor
static inline Tensor _sparse_sum(const Tensor & self, IntArrayRef dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sparse_sum_dim(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_sum", "dim");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, dim);
#endif
}

// aten::_sparse_sum.dim_dtype(Tensor self, int[1] dim, *, ScalarType dtype) -> Tensor
static inline Tensor _sparse_sum(const Tensor & self, IntArrayRef dim, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sparse_sum_dim_dtype(self, dim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_sum", "dim_dtype");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, ScalarType>(self, dim, dtype);
#endif
}

// aten::_sparse_sum_backward(Tensor grad, Tensor self, int[] dim) -> Tensor
static inline Tensor _sparse_sum_backward(const Tensor & grad, const Tensor & self, IntArrayRef dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_sparse_sum_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_sum_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef>(grad, self, dim);
#endif
}

// aten::norm.ScalarOpt_dtype(Tensor self, Scalar? p, *, ScalarType dtype) -> Tensor
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_ScalarOpt_dtype(self, p, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "ScalarOpt_dtype");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Scalar>, ScalarType>(self, p, dtype);
#endif
}

// aten::norm.Scalar(Tensor self, Scalar p=2) -> Tensor
static inline Tensor norm(const Tensor & self, Scalar p) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_Scalar(self, p);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, p);
#endif
}

// aten::norm.ScalarOpt_dim_dtype(Tensor self, Scalar? p, int[1] dim, bool keepdim, *, ScalarType dtype) -> Tensor
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_ScalarOpt_dim_dtype(self, p, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "ScalarOpt_dim_dtype");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Scalar>, IntArrayRef, bool, ScalarType>(self, p, dim, keepdim, dtype);
#endif
}

// aten::norm.ScalarOpt_dim(Tensor self, Scalar? p, int[1] dim, bool keepdim=False) -> Tensor
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_ScalarOpt_dim(self, p, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "ScalarOpt_dim");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Scalar>, IntArrayRef, bool>(self, p, dim, keepdim);
#endif
}

// aten::norm.dtype_out(Tensor self, Scalar? p, int[1] dim, bool keepdim, *, ScalarType dtype, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & norm_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_out_dtype_out(out, self, p, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "dtype_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, c10::optional<Scalar>, IntArrayRef, bool, ScalarType>(out, self, p, dim, keepdim, dtype);
#endif
}

// aten::norm.out(Tensor self, Scalar? p, int[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & norm_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_out_out(out, self, p, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, c10::optional<Scalar>, IntArrayRef, bool>(out, self, p, dim, keepdim);
#endif
}

// aten::norm.names_ScalarOpt_dim_dtype(Tensor self, Scalar? p, Dimname[1] dim, bool keepdim, *, ScalarType dtype) -> Tensor
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, DimnameList dim, bool keepdim, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_names_ScalarOpt_dim_dtype(self, p, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "names_ScalarOpt_dim_dtype");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Scalar>, DimnameList, bool, ScalarType>(self, p, dim, keepdim, dtype);
#endif
}

// aten::norm.names_ScalarOpt_dim(Tensor self, Scalar? p, Dimname[1] dim, bool keepdim=False) -> Tensor
static inline Tensor norm(const Tensor & self, c10::optional<Scalar> p, DimnameList dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_names_ScalarOpt_dim(self, p, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "names_ScalarOpt_dim");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<Scalar>, DimnameList, bool>(self, p, dim, keepdim);
#endif
}

// aten::norm.names_dtype_out(Tensor self, Scalar? p, Dimname[1] dim, bool keepdim, *, ScalarType dtype, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & norm_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, DimnameList dim, bool keepdim, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_out_names_dtype_out(out, self, p, dim, keepdim, dtype);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "names_dtype_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, c10::optional<Scalar>, DimnameList, bool, ScalarType>(out, self, p, dim, keepdim, dtype);
#endif
}

// aten::norm.names_out(Tensor self, Scalar? p, Dimname[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & norm_out(Tensor & out, const Tensor & self, c10::optional<Scalar> p, DimnameList dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::norm_out_names_out(out, self, p, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::norm", "names_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, c10::optional<Scalar>, DimnameList, bool>(out, self, p, dim, keepdim);
#endif
}

// aten::frobenius_norm(Tensor self) -> Tensor
static inline Tensor frobenius_norm(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::frobenius_norm(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::frobenius_norm", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::frobenius_norm.dim(Tensor self, int[1] dim, bool keepdim=False) -> Tensor
static inline Tensor frobenius_norm(const Tensor & self, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::frobenius_norm_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::frobenius_norm", "dim");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool>(self, dim, keepdim);
#endif
}

// aten::frobenius_norm.out(Tensor self, int[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & frobenius_norm_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::frobenius_norm_out_out(out, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::frobenius_norm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool>(out, self, dim, keepdim);
#endif
}

// aten::nuclear_norm(Tensor self, bool keepdim=False) -> Tensor
static inline Tensor nuclear_norm(const Tensor & self, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nuclear_norm(self, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nuclear_norm", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, keepdim);
#endif
}

// aten::nuclear_norm.out(Tensor self, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & nuclear_norm_out(Tensor & out, const Tensor & self, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nuclear_norm_out_out(out, self, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nuclear_norm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, bool>(out, self, keepdim);
#endif
}

// aten::nuclear_norm.dim(Tensor self, int[2] dim, bool keepdim=False) -> Tensor
static inline Tensor nuclear_norm(const Tensor & self, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nuclear_norm_dim(self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nuclear_norm", "dim");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool>(self, dim, keepdim);
#endif
}

// aten::nuclear_norm.dim_out(Tensor self, int[2] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & nuclear_norm_out(Tensor & out, const Tensor & self, IntArrayRef dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nuclear_norm_out_dim_out(out, self, dim, keepdim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nuclear_norm", "dim_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool>(out, self, dim, keepdim);
#endif
}

// aten::clone(Tensor self, *, MemoryFormat? memory_format=None) -> Tensor
static inline Tensor clone(const Tensor & self, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::clone(self, memory_format);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::clone(self, memory_format);
            break;
        default:
            AT_ERROR("clone not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::clone", "");
    return op.callUnboxed<Tensor, const Tensor &, c10::optional<MemoryFormat>>(self, memory_format);
#endif
}

// aten::resize_as_(Tensor(a!) self, Tensor the_template, *, MemoryFormat? memory_format=None) -> Tensor(a!)
static inline Tensor & resize_as_(Tensor & self, const Tensor & the_template, c10::optional<MemoryFormat> memory_format) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::resize_as_(self, the_template, memory_format);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::resize_as_", "");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, c10::optional<MemoryFormat>>(self, the_template, memory_format);
#endif
}

// aten::pow.Tensor_Scalar_out(Tensor self, Scalar exponent, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & pow_out(Tensor & out, const Tensor & self, Scalar exponent) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::pow_out_Tensor_Scalar_out(out, self, exponent);
            break;
        default:
            AT_ERROR("pow_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pow", "Tensor_Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, exponent);
#endif
}

// aten::pow.Tensor_Scalar(Tensor self, Scalar exponent) -> Tensor
static inline Tensor pow(const Tensor & self, Scalar exponent) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::pow_Tensor_Scalar(self, exponent);
            break;
        default:
            AT_ERROR("pow not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pow", "Tensor_Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, exponent);
#endif
}

// aten::zero_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & zero_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::zero_(self);
            break;
        default:
            AT_ERROR("zero_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::zero_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::sub.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sub_out(Tensor & out, const Tensor & self, const Tensor & other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sub_out_out(out, self, other, alpha);
            break;
        default:
            AT_ERROR("sub_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sub", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar>(out, self, other, alpha);
#endif
}

// aten::sub.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor
static inline Tensor sub(const Tensor & self, const Tensor & other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sub_Tensor(self, other, alpha);
            break;
        default:
            AT_ERROR("sub not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sub", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(self, other, alpha);
#endif
}

// aten::sub.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor
static inline Tensor sub(const Tensor & self, Scalar other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sub_Scalar(self, other, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sub", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar>(self, other, alpha);
#endif
}

// aten::rsub.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor
static inline Tensor rsub(const Tensor & self, const Tensor & other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rsub_Tensor(self, other, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rsub", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(self, other, alpha);
#endif
}

// aten::rsub.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor
static inline Tensor rsub(const Tensor & self, Scalar other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rsub_Scalar(self, other, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rsub", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar>(self, other, alpha);
#endif
}

// aten::_sparse_addmm(Tensor self, Tensor sparse, Tensor dense, *, Scalar beta=1, Scalar alpha=1) -> Tensor
static inline Tensor _sparse_addmm(const Tensor & self, const Tensor & sparse, const Tensor & dense, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sparse_addmm(self, sparse, dense, beta, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_addmm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, sparse, dense, beta, alpha);
#endif
}

// aten::addmm.out(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & addmm_out(Tensor & out, const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, mat1, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::addmm_out_out(out, self, mat1, mat2, beta, alpha);
            break;
        default:
            AT_ERROR("addmm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addmm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(out, self, mat1, mat2, beta, alpha);
#endif
}

// aten::addmm(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
static inline Tensor addmm(const Tensor & self, const Tensor & mat1, const Tensor & mat2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, mat1, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::addmm(self, mat1, mat2, beta, alpha);
            break;
        default:
            AT_ERROR("addmm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addmm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, mat1, mat2, beta, alpha);
#endif
}

// aten::sparse_coo_tensor.size(int[] size, *, ScalarType dtype, Layout layout, Device device, bool pin_memory=False) -> Tensor
static inline Tensor sparse_coo_tensor(IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sparse_coo_tensor_size(size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sparse_coo_tensor", "size");
    return op.callUnboxed<Tensor, IntArrayRef, const TensorOptions &>(size, options);
#endif
}

// aten::sparse_coo_tensor.indices(Tensor indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor sparse_coo_tensor(const Tensor & indices, const Tensor & values, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sparse_coo_tensor_indices(indices, values, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sparse_coo_tensor", "indices");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const TensorOptions &>(indices, values, options);
#endif
}

// aten::sparse_coo_tensor.indices_size(Tensor indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor sparse_coo_tensor(const Tensor & indices, const Tensor & values, IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sparse_coo_tensor_indices_size(indices, values, size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sparse_coo_tensor", "indices_size");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const TensorOptions &>(indices, values, size, options);
#endif
}

// aten::_sparse_coo_tensor_unsafe(Tensor indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor _sparse_coo_tensor_unsafe(const Tensor & indices, const Tensor & values, IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_sparse_coo_tensor_unsafe(indices, values, size, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_coo_tensor_unsafe", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const TensorOptions &>(indices, values, size, options);
#endif
}

// aten::_sparse_coo_tensor_with_dims(int sparse_dim, int dense_dim, int[] size, *, ScalarType dtype, Layout layout, Device device, bool pin_memory=False) -> Tensor
static inline Tensor _sparse_coo_tensor_with_dims(int64_t sparse_dim, int64_t dense_dim, IntArrayRef size, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKey _dk = options.computeDispatchKey();
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_sparse_coo_tensor_with_dims not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_coo_tensor_with_dims", "");
    return op.callUnboxed<Tensor, int64_t, int64_t, IntArrayRef, const TensorOptions &>(sparse_dim, dense_dim, size, options);
#endif
}

// aten::_sparse_coo_tensor_with_dims_and_tensors(int sparse_dim, int dense_dim, int[] size, Tensor indices, Tensor values, *, ScalarType dtype, Layout layout, Device device, bool pin_memory=False) -> Tensor
static inline Tensor _sparse_coo_tensor_with_dims_and_tensors(int64_t sparse_dim, int64_t dense_dim, IntArrayRef size, const Tensor & indices, const Tensor & values, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = DispatchKeySet(options.computeDispatchKey()) | c10::detail::multi_dispatch_key_set(indices, values);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_sparse_coo_tensor_with_dims_and_tensors not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_sparse_coo_tensor_with_dims_and_tensors", "");
    return op.callUnboxed<Tensor, int64_t, int64_t, IntArrayRef, const Tensor &, const Tensor &, const TensorOptions &>(sparse_dim, dense_dim, size, indices, values, options);
#endif
}

// aten::to_dense_backward(Tensor grad, Tensor input) -> Tensor
static inline Tensor to_dense_backward(const Tensor & grad, const Tensor & input) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::to_dense_backward(grad, input);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::to_dense_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad, input);
#endif
}

// aten::hspmm.out(Tensor mat1, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & hspmm_out(Tensor & out, const Tensor & mat1, const Tensor & mat2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, mat1, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("hspmm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hspmm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, mat1, mat2);
#endif
}

// aten::hspmm(Tensor mat1, Tensor mat2) -> Tensor
static inline Tensor hspmm(const Tensor & mat1, const Tensor & mat2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(mat1, mat2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("hspmm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hspmm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(mat1, mat2);
#endif
}

// aten::copy_sparse_to_sparse_(Tensor(a!) self, Tensor src, bool non_blocking=False) -> Tensor(a!)
static inline Tensor & copy_sparse_to_sparse_(Tensor & self, const Tensor & src, bool non_blocking) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, src);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("copy_sparse_to_sparse_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::copy_sparse_to_sparse_", "");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, bool>(self, src, non_blocking);
#endif
}

// aten::unbind.int(Tensor(a) self, int dim=0) -> Tensor(a)[]
static inline std::vector<Tensor> unbind(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::unbind_int(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::unbind", "int");
    return op.callUnboxed<std::vector<Tensor>, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::unbind.Dimname(Tensor(a) self, Dimname dim) -> Tensor(a)[]
static inline std::vector<Tensor> unbind(const Tensor & self, Dimname dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::unbind_Dimname(self, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::unbind", "Dimname");
    return op.callUnboxed<std::vector<Tensor>, const Tensor &, Dimname>(self, dim);
#endif
}

// aten::mkldnn_reorder_conv2d_weight(Tensor self, int[2] padding=0, int[2] stride=1, int[2] dilation=1, int groups=1) -> Tensor
static inline Tensor mkldnn_reorder_conv2d_weight(const Tensor & self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("mkldnn_reorder_conv2d_weight not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mkldnn_reorder_conv2d_weight", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, int64_t>(self, padding, stride, dilation, groups);
#endif
}

// aten::to_mkldnn_backward(Tensor grad, Tensor input) -> Tensor
static inline Tensor to_mkldnn_backward(const Tensor & grad, const Tensor & input) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::to_mkldnn_backward(grad, input);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::to_mkldnn_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad, input);
#endif
}

// aten::quantize_per_tensor(Tensor self, float scale, int zero_point, ScalarType dtype) -> Tensor
static inline Tensor quantize_per_tensor(const Tensor & self, double scale, int64_t zero_point, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::quantize_per_tensor(self, scale, zero_point, dtype);
            break;
        default:
            AT_ERROR("quantize_per_tensor not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantize_per_tensor", "");
    return op.callUnboxed<Tensor, const Tensor &, double, int64_t, ScalarType>(self, scale, zero_point, dtype);
#endif
}

// aten::quantize_per_tensor.tensors(Tensor[] tensors, Tensor scales, Tensor zero_points, ScalarType dtype) -> Tensor[]
static inline std::vector<Tensor> quantize_per_tensor(TensorList tensors, const Tensor & scales, const Tensor & zero_points, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(tensors, scales, zero_points);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::quantize_per_tensor_tensors(tensors, scales, zero_points, dtype);
            break;
        default:
            AT_ERROR("quantize_per_tensor not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantize_per_tensor", "tensors");
    return op.callUnboxed<std::vector<Tensor>, TensorList, const Tensor &, const Tensor &, ScalarType>(tensors, scales, zero_points, dtype);
#endif
}

// aten::quantize_per_channel(Tensor self, Tensor scales, Tensor zero_points, int axis, ScalarType dtype) -> Tensor
static inline Tensor quantize_per_channel(const Tensor & self, const Tensor & scales, const Tensor & zero_points, int64_t axis, ScalarType dtype) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, scales, zero_points);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::quantize_per_channel(self, scales, zero_points, axis, dtype);
            break;
        default:
            AT_ERROR("quantize_per_channel not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantize_per_channel", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t, ScalarType>(self, scales, zero_points, axis, dtype);
#endif
}

// aten::dequantize.self(Tensor self) -> Tensor
static inline Tensor dequantize(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::dequantize_self(self);
            break;
        default:
            AT_ERROR("dequantize not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::dequantize", "self");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::dequantize.tensors(Tensor[] tensors) -> Tensor[]
static inline std::vector<Tensor> dequantize(TensorList tensors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(tensors);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::dequantize_tensors(tensors);
            break;
        default:
            AT_ERROR("dequantize not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::dequantize", "tensors");
    return op.callUnboxed<std::vector<Tensor>, TensorList>(tensors);
#endif
}

// aten::q_scale(Tensor self) -> float
static inline double q_scale(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::q_scale(self);
            break;
        default:
            AT_ERROR("q_scale not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::q_scale", "");
    return op.callUnboxed<double, const Tensor &>(self);
#endif
}

// aten::q_zero_point(Tensor self) -> int
static inline int64_t q_zero_point(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::q_zero_point(self);
            break;
        default:
            AT_ERROR("q_zero_point not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::q_zero_point", "");
    return op.callUnboxed<int64_t, const Tensor &>(self);
#endif
}

// aten::q_per_channel_scales(Tensor self) -> Tensor
static inline Tensor q_per_channel_scales(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::q_per_channel_scales(self);
            break;
        default:
            AT_ERROR("q_per_channel_scales not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::q_per_channel_scales", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::q_per_channel_zero_points(Tensor self) -> Tensor
static inline Tensor q_per_channel_zero_points(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::q_per_channel_zero_points(self);
            break;
        default:
            AT_ERROR("q_per_channel_zero_points not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::q_per_channel_zero_points", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::q_per_channel_axis(Tensor self) -> int
static inline int64_t q_per_channel_axis(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::q_per_channel_axis(self);
            break;
        default:
            AT_ERROR("q_per_channel_axis not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::q_per_channel_axis", "");
    return op.callUnboxed<int64_t, const Tensor &>(self);
#endif
}

// aten::int_repr(Tensor self) -> Tensor
static inline Tensor int_repr(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::QuantizedCPU:
            return QuantizedCPUType::int_repr(self);
            break;
        default:
            AT_ERROR("int_repr not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::int_repr", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::_make_per_tensor_quantized_tensor(Tensor self, float scale, int zero_point) -> Tensor
static inline Tensor _make_per_tensor_quantized_tensor(const Tensor & self, double scale, int64_t zero_point) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_make_per_tensor_quantized_tensor(self, scale, zero_point);
            break;
        default:
            AT_ERROR("_make_per_tensor_quantized_tensor not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_make_per_tensor_quantized_tensor", "");
    return op.callUnboxed<Tensor, const Tensor &, double, int64_t>(self, scale, zero_point);
#endif
}

// aten::_make_per_channel_quantized_tensor(Tensor self, Tensor scale, Tensor zero_point, int axis) -> Tensor
static inline Tensor _make_per_channel_quantized_tensor(const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, scale, zero_point);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_make_per_channel_quantized_tensor(self, scale, zero_point, axis);
            break;
        default:
            AT_ERROR("_make_per_channel_quantized_tensor not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_make_per_channel_quantized_tensor", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t>(self, scale, zero_point, axis);
#endif
}

// aten::fake_quantize_per_tensor_affine(Tensor self, float scale, int zero_point, int quant_min, int quant_max) -> Tensor
static inline Tensor fake_quantize_per_tensor_affine(const Tensor & self, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fake_quantize_per_tensor_affine(self, scale, zero_point, quant_min, quant_max);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fake_quantize_per_tensor_affine", "");
    return op.callUnboxed<Tensor, const Tensor &, double, int64_t, int64_t, int64_t>(self, scale, zero_point, quant_min, quant_max);
#endif
}

// aten::fake_quantize_per_tensor_affine_backward(Tensor grad, Tensor self, float scale, int zero_point, int quant_min, int quant_max) -> Tensor
static inline Tensor fake_quantize_per_tensor_affine_backward(const Tensor & grad, const Tensor & self, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fake_quantize_per_tensor_affine_backward(grad, self, scale, zero_point, quant_min, quant_max);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fake_quantize_per_tensor_affine_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, double, int64_t, int64_t, int64_t>(grad, self, scale, zero_point, quant_min, quant_max);
#endif
}

// aten::fake_quantize_per_channel_affine(Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max) -> Tensor
static inline Tensor fake_quantize_per_channel_affine(const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fake_quantize_per_channel_affine(self, scale, zero_point, axis, quant_min, quant_max);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fake_quantize_per_channel_affine", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, int64_t>(self, scale, zero_point, axis, quant_min, quant_max);
#endif
}

// aten::fake_quantize_per_channel_affine_backward(Tensor grad, Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max) -> Tensor
static inline Tensor fake_quantize_per_channel_affine_backward(const Tensor & grad, const Tensor & self, const Tensor & scale, const Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::fake_quantize_per_channel_affine_backward(grad, self, scale, zero_point, axis, quant_min, quant_max);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fake_quantize_per_channel_affine_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, int64_t>(grad, self, scale, zero_point, axis, quant_min, quant_max);
#endif
}

// aten::_choose_qparams_per_tensor(Tensor self, bool reduce_range=False) -> (float, int)
static inline std::tuple<double,int64_t> _choose_qparams_per_tensor(const Tensor & self, bool reduce_range) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_choose_qparams_per_tensor(self, reduce_range);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_choose_qparams_per_tensor", "");
    return op.callUnboxed<std::tuple<double,int64_t>, const Tensor &, bool>(self, reduce_range);
#endif
}

// aten::meshgrid(Tensor[] tensors) -> Tensor[]
static inline std::vector<Tensor> meshgrid(TensorList tensors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::meshgrid(tensors);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::meshgrid", "");
    return op.callUnboxed<std::vector<Tensor>, TensorList>(tensors);
#endif
}

// aten::cartesian_prod(Tensor[] tensors) -> Tensor
static inline Tensor cartesian_prod(TensorList tensors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cartesian_prod(tensors);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cartesian_prod", "");
    return op.callUnboxed<Tensor, TensorList>(tensors);
#endif
}

// aten::combinations(Tensor self, int r=2, bool with_replacement=False) -> Tensor
static inline Tensor combinations(const Tensor & self, int64_t r, bool with_replacement) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::combinations(self, r, with_replacement);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::combinations", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool>(self, r, with_replacement);
#endif
}

// aten::result_type.Tensor(Tensor tensor, Tensor other) -> ScalarType
static inline ScalarType result_type(const Tensor & tensor, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::result_type_Tensor(tensor, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::result_type", "Tensor");
    return op.callUnboxed<ScalarType, const Tensor &, const Tensor &>(tensor, other);
#endif
}

// aten::result_type.Scalar(Tensor tensor, Scalar other) -> ScalarType
static inline ScalarType result_type(const Tensor & tensor, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::result_type_Scalar(tensor, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::result_type", "Scalar");
    return op.callUnboxed<ScalarType, const Tensor &, Scalar>(tensor, other);
#endif
}

// aten::result_type.Scalar_Tensor(Scalar scalar, Tensor tensor) -> ScalarType
static inline ScalarType result_type(Scalar scalar, const Tensor & tensor) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::result_type_Scalar_Tensor(scalar, tensor);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::result_type", "Scalar_Tensor");
    return op.callUnboxed<ScalarType, Scalar, const Tensor &>(scalar, tensor);
#endif
}

// aten::result_type.Scalar_Scalar(Scalar scalar1, Scalar scalar2) -> ScalarType
static inline ScalarType result_type(Scalar scalar1, Scalar scalar2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::result_type_Scalar_Scalar(scalar1, scalar2);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::result_type", "Scalar_Scalar");
    return op.callUnboxed<ScalarType, Scalar, Scalar>(scalar1, scalar2);
#endif
}

// aten::can_cast(ScalarType from, ScalarType to) -> bool
static inline bool can_cast(ScalarType from, ScalarType to) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::can_cast(from, to);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::can_cast", "");
    return op.callUnboxed<bool, ScalarType, ScalarType>(from, to);
#endif
}

// aten::promote_types(ScalarType type1, ScalarType type2) -> ScalarType
static inline ScalarType promote_types(ScalarType type1, ScalarType type2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::promote_types(type1, type2);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::promote_types", "");
    return op.callUnboxed<ScalarType, ScalarType, ScalarType>(type1, type2);
#endif
}

// aten::_local_scalar_dense(Tensor self) -> Scalar
static inline Scalar _local_scalar_dense(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_local_scalar_dense(self);
            break;
        default:
            AT_ERROR("_local_scalar_dense not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_local_scalar_dense", "");
    return op.callUnboxed<Scalar, const Tensor &>(self);
#endif
}

// aten::_thnn_fused_lstm_cell(Tensor input_gates, Tensor hidden_gates, Tensor cx, Tensor? input_bias=None, Tensor? hidden_bias=None) -> (Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input_gates, hidden_gates, cx, input_bias, hidden_bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_thnn_fused_lstm_cell not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_thnn_fused_lstm_cell", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(input_gates, hidden_gates, cx, input_bias, hidden_bias);
#endif
}

// aten::_thnn_fused_lstm_cell_backward(Tensor? grad_hy, Tensor? grad_cy, Tensor cx, Tensor cy, Tensor workspace, bool has_bias) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_hy, grad_cy, cx, cy, workspace);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_thnn_fused_lstm_cell_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_thnn_fused_lstm_cell_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, bool>(grad_hy, grad_cy, cx, cy, workspace, has_bias);
#endif
}

// aten::_thnn_differentiable_lstm_cell_backward(Tensor? grad_hy, Tensor? grad_cy, Tensor input_gates, Tensor hidden_gates, Tensor? input_bias, Tensor? hidden_bias, Tensor cx, Tensor cy) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_differentiable_lstm_cell_backward(const Tensor & grad_hy, const Tensor & grad_cy, const Tensor & input_gates, const Tensor & hidden_gates, const Tensor & input_bias, const Tensor & hidden_bias, const Tensor & cx, const Tensor & cy) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_thnn_differentiable_lstm_cell_backward(grad_hy, grad_cy, input_gates, hidden_gates, input_bias, hidden_bias, cx, cy);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_thnn_differentiable_lstm_cell_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(grad_hy, grad_cy, input_gates, hidden_gates, input_bias, hidden_bias, cx, cy);
#endif
}

// aten::_thnn_fused_gru_cell(Tensor input_gates, Tensor hidden_gates, Tensor hx, Tensor? input_bias=None, Tensor? hidden_bias=None) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(input_gates, hidden_gates, hx, input_bias, hidden_bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_thnn_fused_gru_cell not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_thnn_fused_gru_cell", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(input_gates, hidden_gates, hx, input_bias, hidden_bias);
#endif
}

// aten::_thnn_fused_gru_cell_backward(Tensor grad_hy, Tensor workspace, bool has_bias) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_fused_gru_cell_backward(const Tensor & grad_hy, const Tensor & workspace, bool has_bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_hy, workspace);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_thnn_fused_gru_cell_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_thnn_fused_gru_cell_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, bool>(grad_hy, workspace, has_bias);
#endif
}

// aten::_thnn_differentiable_gru_cell_backward(Tensor grad_hy, Tensor input_gates, Tensor hidden_gates, Tensor hx, Tensor? input_bias, Tensor? hidden_bias) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_differentiable_gru_cell_backward(const Tensor & grad_hy, const Tensor & input_gates, const Tensor & hidden_gates, const Tensor & hx, const Tensor & input_bias, const Tensor & hidden_bias) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_thnn_differentiable_gru_cell_backward(grad_hy, input_gates, hidden_gates, hx, input_bias, hidden_bias);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_thnn_differentiable_gru_cell_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(grad_hy, input_gates, hidden_gates, hx, input_bias, hidden_bias);
#endif
}

// aten::lstm.input(Tensor input, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::lstm_input(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lstm", "input");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, TensorList, TensorList, bool, int64_t, double, bool, bool, bool>(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#endif
}

// aten::lstm.data(Tensor data, Tensor batch_sizes, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::lstm_data(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lstm", "data");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, TensorList, TensorList, bool, int64_t, double, bool, bool>(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#endif
}

// aten::gru.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::gru_input(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gru", "input");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, TensorList, bool, int64_t, double, bool, bool, bool>(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#endif
}

// aten::gru.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::gru_data(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gru", "data");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, TensorList, bool, int64_t, double, bool, bool>(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#endif
}

// aten::rnn_tanh.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rnn_tanh_input(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rnn_tanh", "input");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, TensorList, bool, int64_t, double, bool, bool, bool>(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#endif
}

// aten::rnn_tanh.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rnn_tanh_data(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rnn_tanh", "data");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, TensorList, bool, int64_t, double, bool, bool>(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#endif
}

// aten::rnn_relu.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rnn_relu_input(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rnn_relu", "input");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, TensorList, bool, int64_t, double, bool, bool, bool>(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#endif
}

// aten::rnn_relu.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rnn_relu_data(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rnn_relu", "data");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, TensorList, bool, int64_t, double, bool, bool>(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#endif
}

// aten::lstm_cell(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::lstm_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lstm_cell", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, TensorList, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(input, hx, w_ih, w_hh, b_ih, b_hh);
#endif
}

// aten::gru_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::gru_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gru_cell", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(input, hx, w_ih, w_hh, b_ih, b_hh);
#endif
}

// aten::rnn_tanh_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rnn_tanh_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rnn_tanh_cell", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(input, hx, w_ih, w_hh, b_ih, b_hh);
#endif
}

// aten::rnn_relu_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rnn_relu_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rnn_relu_cell", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &>(input, hx, w_ih, w_hh, b_ih, b_hh);
#endif
}

// aten::quantized_lstm(Tensor input, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first, *, ScalarType? dtype=None, bool use_dynamic=False) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> quantized_lstm(const Tensor & input, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first, c10::optional<ScalarType> dtype, bool use_dynamic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::quantized_lstm(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, dtype, use_dynamic);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_lstm", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, TensorList, TensorList, bool, int64_t, double, bool, bool, bool, c10::optional<ScalarType>, bool>(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, dtype, use_dynamic);
#endif
}

// aten::quantized_lstm.data(Tensor data, Tensor batch_sizes, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, *, ScalarType? dtype=None, bool use_dynamic=False) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> quantized_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, c10::optional<ScalarType> dtype, bool use_dynamic) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::quantized_lstm_data(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional, dtype, use_dynamic);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_lstm", "data");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, TensorList, TensorList, bool, int64_t, double, bool, bool, c10::optional<ScalarType>, bool>(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional, dtype, use_dynamic);
#endif
}

// aten::quantized_gru.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> quantized_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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::quantized_gru_input(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_gru", "input");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, TensorList, bool, int64_t, double, bool, bool, bool>(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
#endif
}

// aten::quantized_gru.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> quantized_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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::quantized_gru_data(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_gru", "data");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, TensorList, bool, int64_t, double, bool, bool>(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
#endif
}

// aten::quantized_lstm_cell(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> quantized_lstm_cell(const Tensor & input, TensorList hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih, const Tensor & b_hh, const Tensor & packed_ih, const Tensor & packed_hh, const Tensor & col_offsets_ih, const Tensor & col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::quantized_lstm_cell(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_lstm_cell", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, TensorList, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, Scalar, Scalar>(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
#endif
}

// aten::quantized_gru_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> Tensor
static inline Tensor quantized_gru_cell(const Tensor & input, const Tensor & hx, const Tensor & w_ih, const Tensor & w_hh, const Tensor & b_ih, const Tensor & b_hh, const Tensor & packed_ih, const Tensor & packed_hh, const Tensor & col_offsets_ih, const Tensor & col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::quantized_gru_cell(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_gru_cell", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, Scalar, Scalar>(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
#endif
}

// aten::quantized_rnn_relu_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> Tensor
static inline Tensor quantized_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, const Tensor & packed_ih, const Tensor & packed_hh, const Tensor & col_offsets_ih, const Tensor & col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::quantized_rnn_relu_cell(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_rnn_relu_cell", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, Scalar, Scalar>(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
#endif
}

// aten::quantized_rnn_tanh_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> Tensor
static inline Tensor quantized_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, const Tensor & packed_ih, const Tensor & packed_hh, const Tensor & col_offsets_ih, const Tensor & col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::quantized_rnn_tanh_cell(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::quantized_rnn_tanh_cell", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, Scalar, Scalar>(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
#endif
}

// aten::_pack_padded_sequence(Tensor input, Tensor lengths, bool batch_first) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _pack_padded_sequence(const Tensor & input, const Tensor & lengths, bool batch_first) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_pack_padded_sequence(input, lengths, batch_first);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_pack_padded_sequence", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, bool>(input, lengths, batch_first);
#endif
}

// aten::_pack_padded_sequence_backward(Tensor grad, int[] input_size, Tensor batch_sizes, bool batch_first) -> Tensor
static inline Tensor _pack_padded_sequence_backward(const Tensor & grad, IntArrayRef input_size, const Tensor & batch_sizes, bool batch_first) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_pack_padded_sequence_backward(grad, input_size, batch_sizes, batch_first);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_pack_padded_sequence_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, const Tensor &, bool>(grad, input_size, batch_sizes, batch_first);
#endif
}

// aten::_pad_packed_sequence(Tensor data, Tensor batch_sizes, bool batch_first, Scalar padding_value, int total_length) -> (Tensor, Tensor)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_pad_packed_sequence(data, batch_sizes, batch_first, padding_value, total_length);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_pad_packed_sequence", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, bool, Scalar, int64_t>(data, batch_sizes, batch_first, padding_value, total_length);
#endif
}

// aten::masked_fill.Scalar(Tensor self, Tensor mask, Scalar value) -> Tensor
static inline Tensor masked_fill(const Tensor & self, const Tensor & mask, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::masked_fill_Scalar(self, mask, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::masked_fill", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(self, mask, value);
#endif
}

// aten::masked_fill.Tensor(Tensor self, Tensor mask, Tensor value) -> Tensor
static inline Tensor masked_fill(const Tensor & self, const Tensor & mask, const Tensor & value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::masked_fill_Tensor(self, mask, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::masked_fill", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(self, mask, value);
#endif
}

// aten::masked_scatter(Tensor self, Tensor mask, Tensor source) -> Tensor
static inline Tensor masked_scatter(const Tensor & self, const Tensor & mask, const Tensor & source) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::masked_scatter(self, mask, source);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::masked_scatter", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(self, mask, source);
#endif
}

// aten::index_add(Tensor self, int dim, Tensor index, Tensor source) -> Tensor
static inline Tensor index_add(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & source) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_add(self, dim, index, source);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_add", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, const Tensor &>(self, dim, index, source);
#endif
}

// aten::index_add.dimname(Tensor self, Dimname dim, Tensor index, Tensor source) -> Tensor
static inline Tensor index_add(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & source) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_add_dimname(self, dim, index, source);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_add", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &, const Tensor &>(self, dim, index, source);
#endif
}

// aten::index_fill.int_Scalar(Tensor self, int dim, Tensor index, Scalar value) -> Tensor
static inline Tensor index_fill(const Tensor & self, int64_t dim, const Tensor & index, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_fill_int_Scalar(self, dim, index, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_fill", "int_Scalar");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, Scalar>(self, dim, index, value);
#endif
}

// aten::index_fill.int_Tensor(Tensor self, int dim, Tensor index, Tensor value) -> Tensor
static inline Tensor index_fill(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_fill_int_Tensor(self, dim, index, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_fill", "int_Tensor");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, const Tensor &>(self, dim, index, value);
#endif
}

// aten::index_fill.Dimname_Scalar(Tensor self, Dimname dim, Tensor index, Scalar value) -> Tensor
static inline Tensor index_fill(const Tensor & self, Dimname dim, const Tensor & index, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_fill_Dimname_Scalar(self, dim, index, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_fill", "Dimname_Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &, Scalar>(self, dim, index, value);
#endif
}

// aten::index_fill.Dimname_Tensor(Tensor self, Dimname dim, Tensor index, Tensor value) -> Tensor
static inline Tensor index_fill(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_fill_Dimname_Tensor(self, dim, index, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_fill", "Dimname_Tensor");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &, const Tensor &>(self, dim, index, value);
#endif
}

// aten::scatter.src(Tensor self, int dim, Tensor index, Tensor src) -> Tensor
static inline Tensor scatter(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & src) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::scatter_src(self, dim, index, src);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::scatter", "src");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, const Tensor &>(self, dim, index, src);
#endif
}

// aten::scatter.value(Tensor self, int dim, Tensor index, Scalar value) -> Tensor
static inline Tensor scatter(const Tensor & self, int64_t dim, const Tensor & index, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::scatter_value(self, dim, index, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::scatter", "value");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, Scalar>(self, dim, index, value);
#endif
}

// aten::scatter.dimname_src(Tensor self, Dimname dim, Tensor index, Tensor src) -> Tensor
static inline Tensor scatter(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & src) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::scatter_dimname_src(self, dim, index, src);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::scatter", "dimname_src");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &, const Tensor &>(self, dim, index, src);
#endif
}

// aten::scatter.dimname_value(Tensor self, Dimname dim, Tensor index, Scalar value) -> Tensor
static inline Tensor scatter(const Tensor & self, Dimname dim, const Tensor & index, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::scatter_dimname_value(self, dim, index, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::scatter", "dimname_value");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &, Scalar>(self, dim, index, value);
#endif
}

// aten::scatter_add(Tensor self, int dim, Tensor index, Tensor src) -> Tensor
static inline Tensor scatter_add(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & src) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::scatter_add(self, dim, index, src);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::scatter_add", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, const Tensor &>(self, dim, index, src);
#endif
}

// aten::scatter_add.dimname(Tensor self, Dimname dim, Tensor index, Tensor src) -> Tensor
static inline Tensor scatter_add(const Tensor & self, Dimname dim, const Tensor & index, const Tensor & src) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::scatter_add_dimname(self, dim, index, src);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::scatter_add", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &, const Tensor &>(self, dim, index, src);
#endif
}

// aten::bitwise_and.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bitwise_and_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bitwise_and_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("bitwise_and_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_and", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::bitwise_and.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bitwise_and_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bitwise_and_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("bitwise_and_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_and", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::bitwise_and.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor bitwise_and(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bitwise_and_Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_and", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::bitwise_and.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor bitwise_and(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bitwise_and_Tensor(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_and", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::__and__.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor __and__(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::__and___Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__and__", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::__and__.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor __and__(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::__and___Tensor(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__and__", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::bitwise_or.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bitwise_or_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bitwise_or_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("bitwise_or_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_or", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::bitwise_or.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bitwise_or_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bitwise_or_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("bitwise_or_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_or", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::bitwise_or.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor bitwise_or(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bitwise_or_Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_or", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::bitwise_or.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor bitwise_or(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bitwise_or_Tensor(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_or", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::__or__.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor __or__(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::__or___Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__or__", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::__or__.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor __or__(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::__or___Tensor(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__or__", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::bitwise_xor.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bitwise_xor_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bitwise_xor_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("bitwise_xor_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_xor", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::bitwise_xor.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bitwise_xor_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bitwise_xor_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("bitwise_xor_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_xor", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::bitwise_xor.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor bitwise_xor(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bitwise_xor_Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_xor", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::bitwise_xor.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor bitwise_xor(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::bitwise_xor_Tensor(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bitwise_xor", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::__xor__.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor __xor__(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::__xor___Scalar(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__xor__", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::__xor__.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor __xor__(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::__xor___Tensor(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__xor__", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::__lshift__.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor __lshift__(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::__lshift___Scalar(self, other);
            break;
        default:
            AT_ERROR("__lshift__ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__lshift__", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::__lshift__.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor __lshift__(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::__lshift___Tensor(self, other);
            break;
        default:
            AT_ERROR("__lshift__ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__lshift__", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::__rshift__.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor __rshift__(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::__rshift___Scalar(self, other);
            break;
        default:
            AT_ERROR("__rshift__ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__rshift__", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::__rshift__.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor __rshift__(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::__rshift___Tensor(self, other);
            break;
        default:
            AT_ERROR("__rshift__ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::__rshift__", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::addbmm.out(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & addbmm_out(Tensor & out, const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, batch1, batch2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::addbmm_out_out(out, self, batch1, batch2, beta, alpha);
            break;
        default:
            AT_ERROR("addbmm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addbmm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(out, self, batch1, batch2, beta, alpha);
#endif
}

// aten::addbmm(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
static inline Tensor addbmm(const Tensor & self, const Tensor & batch1, const Tensor & batch2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, batch1, batch2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::addbmm(self, batch1, batch2, beta, alpha);
            break;
        default:
            AT_ERROR("addbmm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addbmm", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, batch1, batch2, beta, alpha);
#endif
}

// aten::diag.out(Tensor self, int diagonal=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & diag_out(Tensor & out, const Tensor & self, int64_t diagonal) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::diag_out_out(out, self, diagonal);
            break;
        default:
            AT_ERROR("diag_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::diag", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t>(out, self, diagonal);
#endif
}

// aten::diag(Tensor self, int diagonal=0) -> Tensor
static inline Tensor diag(const Tensor & self, int64_t diagonal) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::diag(self, diagonal);
            break;
        default:
            AT_ERROR("diag not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::diag", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, diagonal);
#endif
}

// aten::cross.out(Tensor self, Tensor other, int? dim=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cross_out(Tensor & out, const Tensor & self, const Tensor & other, c10::optional<int64_t> dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cross_out_out(out, self, other, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cross", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, c10::optional<int64_t>>(out, self, other, dim);
#endif
}

// aten::cross(Tensor self, Tensor other, int? dim=None) -> Tensor
static inline Tensor cross(const Tensor & self, const Tensor & other, c10::optional<int64_t> dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cross(self, other, dim);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cross", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, c10::optional<int64_t>>(self, other, dim);
#endif
}

// aten::triu.out(Tensor self, int diagonal=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & triu_out(Tensor & out, const Tensor & self, int64_t diagonal) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::triu_out_out(out, self, diagonal);
            break;
        default:
            AT_ERROR("triu_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::triu", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t>(out, self, diagonal);
#endif
}

// aten::triu(Tensor self, int diagonal=0) -> Tensor
static inline Tensor triu(const Tensor & self, int64_t diagonal) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::triu(self, diagonal);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::triu", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, diagonal);
#endif
}

// aten::tril.out(Tensor self, int diagonal=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & tril_out(Tensor & out, const Tensor & self, int64_t diagonal) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::tril_out_out(out, self, diagonal);
            break;
        default:
            AT_ERROR("tril_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tril", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t>(out, self, diagonal);
#endif
}

// aten::tril(Tensor self, int diagonal=0) -> Tensor
static inline Tensor tril(const Tensor & self, int64_t diagonal) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::tril(self, diagonal);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tril", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, diagonal);
#endif
}

// aten::tril_indices(int row, int col, int offset=0, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor tril_indices(int64_t row, int64_t col, int64_t offset, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKey _dk = options.computeDispatchKey();
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::tril_indices(row, col, offset, options);
            break;
        default:
            AT_ERROR("tril_indices not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tril_indices", "");
    return op.callUnboxed<Tensor, int64_t, int64_t, int64_t, const TensorOptions &>(row, col, offset, options);
#endif
}

// aten::triu_indices(int row, int col, int offset=0, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor triu_indices(int64_t row, int64_t col, int64_t offset, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKey _dk = options.computeDispatchKey();
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::triu_indices(row, col, offset, options);
            break;
        default:
            AT_ERROR("triu_indices not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::triu_indices", "");
    return op.callUnboxed<Tensor, int64_t, int64_t, int64_t, const TensorOptions &>(row, col, offset, options);
#endif
}

// aten::trace(Tensor self) -> Tensor
static inline Tensor trace(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::trace(self);
            break;
        default:
            AT_ERROR("trace not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::trace", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::ne.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & ne_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ne_out_Scalar_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::ne_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("ne_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ne", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::ne.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor ne(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ne_Scalar(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::ne_Scalar(self, other);
            break;
        default:
            AT_ERROR("ne not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ne", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::ne.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & ne_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ne_out_Tensor_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::ne_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("ne_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ne", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::ne.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor ne(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ne_Tensor(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::ne_Tensor(self, other);
            break;
        default:
            AT_ERROR("ne not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ne", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::eq.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & eq_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::eq_out_Scalar_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::eq_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("eq_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eq", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::eq.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor eq(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::eq_Scalar(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::eq_Scalar(self, other);
            break;
        default:
            AT_ERROR("eq not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eq", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::eq.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & eq_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::eq_out_Tensor_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::eq_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("eq_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eq", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::eq.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor eq(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::eq_Tensor(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::eq_Tensor(self, other);
            break;
        default:
            AT_ERROR("eq not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eq", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::ge.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & ge_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ge_out_Scalar_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::ge_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("ge_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ge", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::ge.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor ge(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ge_Scalar(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::ge_Scalar(self, other);
            break;
        default:
            AT_ERROR("ge not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ge", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::ge.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & ge_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ge_out_Tensor_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::ge_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("ge_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ge", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::ge.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor ge(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ge_Tensor(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::ge_Tensor(self, other);
            break;
        default:
            AT_ERROR("ge not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ge", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::le.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & le_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::le_out_Scalar_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::le_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("le_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::le", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::le.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor le(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::le_Scalar(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::le_Scalar(self, other);
            break;
        default:
            AT_ERROR("le not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::le", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::le.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & le_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::le_out_Tensor_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::le_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("le_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::le", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::le.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor le(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::le_Tensor(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::le_Tensor(self, other);
            break;
        default:
            AT_ERROR("le not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::le", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::gt.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & gt_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::gt_out_Scalar_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::gt_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("gt_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gt", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::gt.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor gt(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::gt_Scalar(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::gt_Scalar(self, other);
            break;
        default:
            AT_ERROR("gt not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gt", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::gt.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & gt_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::gt_out_Tensor_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::gt_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("gt_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gt", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::gt.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor gt(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::gt_Tensor(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::gt_Tensor(self, other);
            break;
        default:
            AT_ERROR("gt not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gt", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::lt.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & lt_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lt_out_Scalar_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::lt_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("lt_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lt", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::lt.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor lt(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lt_Scalar(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::lt_Scalar(self, other);
            break;
        default:
            AT_ERROR("lt not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lt", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::lt.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & lt_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lt_out_Tensor_out(out, self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::lt_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("lt_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lt", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::lt.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor lt(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lt_Tensor(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::lt_Tensor(self, other);
            break;
        default:
            AT_ERROR("lt not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lt", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::take.out(Tensor self, Tensor index, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & take_out(Tensor & out, const Tensor & self, const Tensor & index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, index);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::take_out_out(out, self, index);
            break;
        default:
            AT_ERROR("take_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::take", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, index);
#endif
}

// aten::take(Tensor self, Tensor index) -> Tensor
static inline Tensor take(const Tensor & self, const Tensor & index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, index);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::take(self, index);
            break;
        default:
            AT_ERROR("take not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::take", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, index);
#endif
}

// aten::index_select.out(Tensor self, int dim, Tensor index, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & index_select_out(Tensor & out, const Tensor & self, int64_t dim, const Tensor & index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, index);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::index_select_out_out(out, self, dim, index);
            break;
        default:
            AT_ERROR("index_select_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_select", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, const Tensor &>(out, self, dim, index);
#endif
}

// aten::index_select(Tensor self, int dim, Tensor index) -> Tensor
static inline Tensor index_select(const Tensor & self, int64_t dim, const Tensor & index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, index);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::index_select(self, dim, index);
            break;
        default:
            AT_ERROR("index_select not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_select", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &>(self, dim, index);
#endif
}

// aten::index_select.dimname_out(Tensor self, Dimname dim, Tensor index, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & index_select_out(Tensor & out, const Tensor & self, Dimname dim, const Tensor & index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_select_out_dimname_out(out, self, dim, index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_select", "dimname_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Dimname, const Tensor &>(out, self, dim, index);
#endif
}

// aten::index_select.dimname(Tensor self, Dimname dim, Tensor index) -> Tensor
static inline Tensor index_select(const Tensor & self, Dimname dim, const Tensor & index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::index_select_dimname(self, dim, index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::index_select", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &>(self, dim, index);
#endif
}

// aten::masked_select.out(Tensor self, Tensor mask, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & masked_select_out(Tensor & out, const Tensor & self, const Tensor & mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, mask);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::masked_select_out_out(out, self, mask);
            break;
        default:
            AT_ERROR("masked_select_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::masked_select", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, mask);
#endif
}

// aten::masked_select(Tensor self, Tensor mask) -> Tensor
static inline Tensor masked_select(const Tensor & self, const Tensor & mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, mask);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::masked_select(self, mask);
            break;
        default:
            AT_ERROR("masked_select not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::masked_select", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, mask);
#endif
}

// aten::nonzero.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & nonzero_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nonzero_out_out(out, self);
            break;
        default:
            AT_ERROR("nonzero_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nonzero", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::nonzero(Tensor self) -> Tensor
static inline Tensor nonzero(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nonzero(self);
            break;
        default:
            AT_ERROR("nonzero not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nonzero", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::nonzero_numpy(Tensor self) -> Tensor[]
static inline std::vector<Tensor> nonzero_numpy(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nonzero_numpy(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nonzero_numpy", "");
    return op.callUnboxed<std::vector<Tensor>, const Tensor &>(self);
#endif
}

// aten::gather.out(Tensor self, int dim, Tensor index, *, bool sparse_grad=False, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & gather_out(Tensor & out, const Tensor & self, int64_t dim, const Tensor & index, bool sparse_grad) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, index);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::gather_out_out(out, self, dim, index, sparse_grad);
            break;
        default:
            AT_ERROR("gather_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gather", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, const Tensor &, bool>(out, self, dim, index, sparse_grad);
#endif
}

// aten::gather(Tensor self, int dim, Tensor index, *, bool sparse_grad=False) -> Tensor
static inline Tensor gather(const Tensor & self, int64_t dim, const Tensor & index, bool sparse_grad) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, index);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::gather(self, dim, index, sparse_grad);
            break;
        default:
            AT_ERROR("gather not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gather", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, bool>(self, dim, index, sparse_grad);
#endif
}

// aten::gather.dimname_out(Tensor self, Dimname dim, Tensor index, *, bool sparse_grad=False, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & gather_out(Tensor & out, const Tensor & self, Dimname dim, const Tensor & index, bool sparse_grad) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::gather_out_dimname_out(out, self, dim, index, sparse_grad);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gather", "dimname_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Dimname, const Tensor &, bool>(out, self, dim, index, sparse_grad);
#endif
}

// aten::gather.dimname(Tensor self, Dimname dim, Tensor index, *, bool sparse_grad=False) -> Tensor
static inline Tensor gather(const Tensor & self, Dimname dim, const Tensor & index, bool sparse_grad) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::gather_dimname(self, dim, index, sparse_grad);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::gather", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, const Tensor &, bool>(self, dim, index, sparse_grad);
#endif
}

// aten::_gather_sparse_backward(Tensor self, int dim, Tensor index, Tensor grad) -> Tensor
static inline Tensor _gather_sparse_backward(const Tensor & self, int64_t dim, const Tensor & index, const Tensor & grad) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_gather_sparse_backward(self, dim, index, grad);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_gather_sparse_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, const Tensor &, const Tensor &>(self, dim, index, grad);
#endif
}

// aten::addcmul.out(Tensor self, Tensor tensor1, Tensor tensor2, *, Scalar value=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & addcmul_out(Tensor & out, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::addcmul_out_out(out, self, tensor1, tensor2, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addcmul", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar>(out, self, tensor1, tensor2, value);
#endif
}

// aten::addcmul(Tensor self, Tensor tensor1, Tensor tensor2, *, Scalar value=1) -> Tensor
static inline Tensor addcmul(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::addcmul(self, tensor1, tensor2, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addcmul", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar>(self, tensor1, tensor2, value);
#endif
}

// aten::addcdiv.out(Tensor self, Tensor tensor1, Tensor tensor2, *, Scalar value=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & addcdiv_out(Tensor & out, const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::addcdiv_out_out(out, self, tensor1, tensor2, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addcdiv", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar>(out, self, tensor1, tensor2, value);
#endif
}

// aten::addcdiv(Tensor self, Tensor tensor1, Tensor tensor2, *, Scalar value=1) -> Tensor
static inline Tensor addcdiv(const Tensor & self, const Tensor & tensor1, const Tensor & tensor2, Scalar value) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::addcdiv(self, tensor1, tensor2, value);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::addcdiv", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar>(self, tensor1, tensor2, value);
#endif
}

// aten::lstsq.X(Tensor self, Tensor A, *, Tensor(a!) X, Tensor(b!) qr) -> (Tensor(a!) solution, Tensor(b!) QR)
static inline std::tuple<Tensor &,Tensor &> lstsq_out(Tensor & X, Tensor & qr, const Tensor & self, const Tensor & A) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(X, qr, self, A);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lstsq_out_X(X, qr, self, A);
            break;
        default:
            AT_ERROR("lstsq_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lstsq", "X");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, const Tensor &>(X, qr, self, A);
#endif
}

// aten::lstsq(Tensor self, Tensor A) -> (Tensor solution, Tensor QR)
static inline std::tuple<Tensor,Tensor> lstsq(const Tensor & self, const Tensor & A) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, A);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lstsq(self, A);
            break;
        default:
            AT_ERROR("lstsq not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lstsq", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &>(self, A);
#endif
}

// aten::triangular_solve.X(Tensor self, Tensor A, bool upper=True, bool transpose=False, bool unitriangular=False, *, Tensor(a!) X, Tensor(b!) M) -> (Tensor(a!) solution, Tensor(b!) cloned_coefficient)
static inline std::tuple<Tensor &,Tensor &> triangular_solve_out(Tensor & X, Tensor & M, const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::triangular_solve_out_X(X, M, self, A, upper, transpose, unitriangular);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::triangular_solve", "X");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, const Tensor &, bool, bool, bool>(X, M, self, A, upper, transpose, unitriangular);
#endif
}

// aten::triangular_solve(Tensor self, Tensor A, bool upper=True, bool transpose=False, bool unitriangular=False) -> (Tensor solution, Tensor cloned_coefficient)
static inline std::tuple<Tensor,Tensor> triangular_solve(const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::triangular_solve(self, A, upper, transpose, unitriangular);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::triangular_solve", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, bool, bool, bool>(self, A, upper, transpose, unitriangular);
#endif
}

// aten::_triangular_solve_helper(Tensor self, Tensor A, bool upper, bool transpose, bool unitriangular) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _triangular_solve_helper(const Tensor & self, const Tensor & A, bool upper, bool transpose, bool unitriangular) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, A);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_triangular_solve_helper(self, A, upper, transpose, unitriangular);
            break;
        default:
            AT_ERROR("_triangular_solve_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_triangular_solve_helper", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, bool, bool, bool>(self, A, upper, transpose, unitriangular);
#endif
}

// aten::symeig.e(Tensor self, bool eigenvectors=False, bool upper=True, *, Tensor(a!) e, Tensor(b!) V) -> (Tensor(a!) eigenvalues, Tensor(b!) eigenvectors)
static inline std::tuple<Tensor &,Tensor &> symeig_out(Tensor & e, Tensor & V, const Tensor & self, bool eigenvectors, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::symeig_out_e(e, V, self, eigenvectors, upper);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::symeig", "e");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, bool, bool>(e, V, self, eigenvectors, upper);
#endif
}

// aten::symeig(Tensor self, bool eigenvectors=False, bool upper=True) -> (Tensor eigenvalues, Tensor eigenvectors)
static inline std::tuple<Tensor,Tensor> symeig(const Tensor & self, bool eigenvectors, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::symeig(self, eigenvectors, upper);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::symeig", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, bool, bool>(self, eigenvectors, upper);
#endif
}

// aten::_symeig_helper(Tensor self, bool eigenvectors, bool upper) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _symeig_helper(const Tensor & self, bool eigenvectors, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_symeig_helper(self, eigenvectors, upper);
            break;
        default:
            AT_ERROR("_symeig_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_symeig_helper", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, bool, bool>(self, eigenvectors, upper);
#endif
}

// aten::eig.e(Tensor self, bool eigenvectors=False, *, Tensor(a!) e, Tensor(b!) v) -> (Tensor(a!) eigenvalues, Tensor(b!) eigenvectors)
static inline std::tuple<Tensor &,Tensor &> eig_out(Tensor & e, Tensor & v, const Tensor & self, bool eigenvectors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(e, v, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::eig_out_e(e, v, self, eigenvectors);
            break;
        default:
            AT_ERROR("eig_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eig", "e");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, bool>(e, v, self, eigenvectors);
#endif
}

// aten::eig(Tensor self, bool eigenvectors=False) -> (Tensor eigenvalues, Tensor eigenvectors)
static inline std::tuple<Tensor,Tensor> eig(const Tensor & self, bool eigenvectors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::eig(self, eigenvectors);
            break;
        default:
            AT_ERROR("eig not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::eig", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, bool>(self, eigenvectors);
#endif
}

// aten::svd.U(Tensor self, bool some=True, bool compute_uv=True, *, Tensor(a!) U, Tensor(b!) S, Tensor(c!) V) -> (Tensor(a!) U, Tensor(b!) S, Tensor(c!) V)
static inline std::tuple<Tensor &,Tensor &,Tensor &> svd_out(Tensor & U, Tensor & S, Tensor & V, const Tensor & self, bool some, bool compute_uv) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::svd_out_U(U, S, V, self, some, compute_uv);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::svd", "U");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &,Tensor &>, Tensor &, Tensor &, Tensor &, const Tensor &, bool, bool>(U, S, V, self, some, compute_uv);
#endif
}

// aten::svd(Tensor self, bool some=True, bool compute_uv=True) -> (Tensor U, Tensor S, Tensor V)
static inline std::tuple<Tensor,Tensor,Tensor> svd(const Tensor & self, bool some, bool compute_uv) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::svd(self, some, compute_uv);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::svd", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, bool, bool>(self, some, compute_uv);
#endif
}

// aten::_svd_helper(Tensor self, bool some, bool compute_uv) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> _svd_helper(const Tensor & self, bool some, bool compute_uv) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_svd_helper(self, some, compute_uv);
            break;
        default:
            AT_ERROR("_svd_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_svd_helper", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, bool, bool>(self, some, compute_uv);
#endif
}

// aten::cholesky.out(Tensor self, bool upper=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cholesky_out(Tensor & out, const Tensor & self, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cholesky_out_out(out, self, upper);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cholesky", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, bool>(out, self, upper);
#endif
}

// aten::cholesky(Tensor self, bool upper=False) -> Tensor
static inline Tensor cholesky(const Tensor & self, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cholesky(self, upper);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cholesky", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, upper);
#endif
}

// aten::_cholesky_helper(Tensor self, bool upper) -> Tensor
static inline Tensor _cholesky_helper(const Tensor & self, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_cholesky_helper(self, upper);
            break;
        default:
            AT_ERROR("_cholesky_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cholesky_helper", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, upper);
#endif
}

// aten::cholesky_solve.out(Tensor self, Tensor input2, bool upper=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cholesky_solve_out(Tensor & out, const Tensor & self, const Tensor & input2, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cholesky_solve_out_out(out, self, input2, upper);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cholesky_solve", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, bool>(out, self, input2, upper);
#endif
}

// aten::cholesky_solve(Tensor self, Tensor input2, bool upper=False) -> Tensor
static inline Tensor cholesky_solve(const Tensor & self, const Tensor & input2, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::cholesky_solve(self, input2, upper);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cholesky_solve", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, bool>(self, input2, upper);
#endif
}

// aten::_cholesky_solve_helper(Tensor self, Tensor A, bool upper) -> Tensor
static inline Tensor _cholesky_solve_helper(const Tensor & self, const Tensor & A, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, A);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_cholesky_solve_helper(self, A, upper);
            break;
        default:
            AT_ERROR("_cholesky_solve_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cholesky_solve_helper", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, bool>(self, A, upper);
#endif
}

// aten::solve(Tensor self, Tensor A) -> (Tensor solution, Tensor LU)
static inline std::tuple<Tensor,Tensor> solve(const Tensor & self, const Tensor & A) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::solve(self, A);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::solve", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &>(self, A);
#endif
}

// aten::solve.solution(Tensor self, Tensor A, *, Tensor(a!) solution, Tensor(b!) lu) -> (Tensor(a!) solution, Tensor(b!) LU)
static inline std::tuple<Tensor &,Tensor &> solve_out(Tensor & solution, Tensor & lu, const Tensor & self, const Tensor & A) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::solve_out_solution(solution, lu, self, A);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::solve", "solution");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, const Tensor &>(solution, lu, self, A);
#endif
}

// aten::_solve_helper(Tensor self, Tensor A) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _solve_helper(const Tensor & self, const Tensor & A) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, A);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_solve_helper(self, A);
            break;
        default:
            AT_ERROR("_solve_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_solve_helper", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &>(self, A);
#endif
}

// aten::cholesky_inverse.out(Tensor self, bool upper=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & cholesky_inverse_out(Tensor & out, const Tensor & self, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::cholesky_inverse_out_out(out, self, upper);
            break;
        default:
            AT_ERROR("cholesky_inverse_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cholesky_inverse", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, bool>(out, self, upper);
#endif
}

// aten::cholesky_inverse(Tensor self, bool upper=False) -> Tensor
static inline Tensor cholesky_inverse(const Tensor & self, bool upper) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::cholesky_inverse(self, upper);
            break;
        default:
            AT_ERROR("cholesky_inverse not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::cholesky_inverse", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, upper);
#endif
}

// aten::qr.Q(Tensor self, bool some=True, *, Tensor(a!) Q, Tensor(b!) R) -> (Tensor(a!) Q, Tensor(b!) R)
static inline std::tuple<Tensor &,Tensor &> qr_out(Tensor & Q, Tensor & R, const Tensor & self, bool some) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::qr_out_Q(Q, R, self, some);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::qr", "Q");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, bool>(Q, R, self, some);
#endif
}

// aten::qr(Tensor self, bool some=True) -> (Tensor Q, Tensor R)
static inline std::tuple<Tensor,Tensor> qr(const Tensor & self, bool some) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::qr(self, some);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::qr", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, bool>(self, some);
#endif
}

// aten::_qr_helper(Tensor self, bool some) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _qr_helper(const Tensor & self, bool some) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_qr_helper(self, some);
            break;
        default:
            AT_ERROR("_qr_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_qr_helper", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, bool>(self, some);
#endif
}

// aten::geqrf.a(Tensor self, *, Tensor(a!) a, Tensor(b!) tau) -> (Tensor(a!) a, Tensor(b!) tau)
static inline std::tuple<Tensor &,Tensor &> geqrf_out(Tensor & a, Tensor & tau, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(a, tau, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::geqrf_out_a(a, tau, self);
            break;
        default:
            AT_ERROR("geqrf_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::geqrf", "a");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &>(a, tau, self);
#endif
}

// aten::geqrf(Tensor self) -> (Tensor a, Tensor tau)
static inline std::tuple<Tensor,Tensor> geqrf(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::geqrf(self);
            break;
        default:
            AT_ERROR("geqrf not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::geqrf", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &>(self);
#endif
}

// aten::orgqr.out(Tensor self, Tensor input2, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & orgqr_out(Tensor & out, const Tensor & self, const Tensor & input2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, input2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::orgqr_out_out(out, self, input2);
            break;
        default:
            AT_ERROR("orgqr_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::orgqr", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, input2);
#endif
}

// aten::orgqr(Tensor self, Tensor input2) -> Tensor
static inline Tensor orgqr(const Tensor & self, const Tensor & input2) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, input2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::orgqr(self, input2);
            break;
        default:
            AT_ERROR("orgqr not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::orgqr", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, input2);
#endif
}

// aten::ormqr.out(Tensor self, Tensor input2, Tensor input3, bool left=True, bool transpose=False, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & ormqr_out(Tensor & out, const Tensor & self, const Tensor & input2, const Tensor & input3, bool left, bool transpose) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, input2, input3);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ormqr_out_out(out, self, input2, input3, left, transpose);
            break;
        default:
            AT_ERROR("ormqr_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ormqr", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, bool, bool>(out, self, input2, input3, left, transpose);
#endif
}

// aten::ormqr(Tensor self, Tensor input2, Tensor input3, bool left=True, bool transpose=False) -> Tensor
static inline Tensor ormqr(const Tensor & self, const Tensor & input2, const Tensor & input3, bool left, bool transpose) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, input2, input3);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::ormqr(self, input2, input3, left, transpose);
            break;
        default:
            AT_ERROR("ormqr not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::ormqr", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, bool, bool>(self, input2, input3, left, transpose);
#endif
}

// aten::_lu_with_info(Tensor self, bool pivot=True, bool check_errors=True) -> (Tensor, Tensor, Tensor)
static inline std::tuple<Tensor,Tensor,Tensor> _lu_with_info(const Tensor & self, bool pivot, bool check_errors) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_lu_with_info(self, pivot, check_errors);
            break;
        default:
            AT_ERROR("_lu_with_info not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_lu_with_info", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, bool, bool>(self, pivot, check_errors);
#endif
}

// aten::lu_solve.out(Tensor self, Tensor LU_data, Tensor LU_pivots, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & lu_solve_out(Tensor & out, const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::lu_solve_out_out(out, self, LU_data, LU_pivots);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lu_solve", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &>(out, self, LU_data, LU_pivots);
#endif
}

// aten::lu_solve(Tensor self, Tensor LU_data, Tensor LU_pivots) -> Tensor
static inline Tensor lu_solve(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::lu_solve(self, LU_data, LU_pivots);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lu_solve", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(self, LU_data, LU_pivots);
#endif
}

// aten::_lu_solve_helper(Tensor self, Tensor LU_data, Tensor LU_pivots) -> Tensor
static inline Tensor _lu_solve_helper(const Tensor & self, const Tensor & LU_data, const Tensor & LU_pivots) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, LU_data, LU_pivots);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_lu_solve_helper(self, LU_data, LU_pivots);
            break;
        default:
            AT_ERROR("_lu_solve_helper not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_lu_solve_helper", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(self, LU_data, LU_pivots);
#endif
}

// aten::multinomial.out(Tensor self, int num_samples, bool replacement=False, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & multinomial_out(Tensor & out, const Tensor & self, int64_t num_samples, bool replacement, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multinomial_out_out(out, self, num_samples, replacement, generator);
            break;
        default:
            AT_ERROR("multinomial_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multinomial", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, bool, c10::optional<Generator>>(out, self, num_samples, replacement, generator);
#endif
}

// aten::multinomial(Tensor self, int num_samples, bool replacement=False, *, Generator? generator=None) -> Tensor
static inline Tensor multinomial(const Tensor & self, int64_t num_samples, bool replacement, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multinomial(self, num_samples, replacement, generator);
            break;
        default:
            AT_ERROR("multinomial not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multinomial", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool, c10::optional<Generator>>(self, num_samples, replacement, generator);
#endif
}

// aten::_multinomial_alias_setup(Tensor probs) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _multinomial_alias_setup(const Tensor & probs) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(probs);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_multinomial_alias_setup(probs);
            break;
        default:
            AT_ERROR("_multinomial_alias_setup not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_multinomial_alias_setup", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &>(probs);
#endif
}

// aten::_multinomial_alias_draw(Tensor J, Tensor q, int num_samples, *, Generator? generator=None) -> Tensor
static inline Tensor _multinomial_alias_draw(const Tensor & J, const Tensor & q, int64_t num_samples, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(J, q);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_multinomial_alias_draw(J, q, num_samples, generator);
            break;
        default:
            AT_ERROR("_multinomial_alias_draw not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_multinomial_alias_draw", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t, c10::optional<Generator>>(J, q, num_samples, generator);
#endif
}

// aten::lgamma.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & lgamma_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lgamma_out_out(out, self);
            break;
        default:
            AT_ERROR("lgamma_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lgamma", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::lgamma(Tensor self) -> Tensor
static inline Tensor lgamma(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lgamma(self);
            break;
        default:
            AT_ERROR("lgamma not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lgamma", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::digamma.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & digamma_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::digamma_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::digamma", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::digamma(Tensor self) -> Tensor
static inline Tensor digamma(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::digamma(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::digamma", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::polygamma.out(int n, Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & polygamma_out(Tensor & out, int64_t n, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::polygamma_out_out(out, n, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::polygamma", "out");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, const Tensor &>(out, n, self);
#endif
}

// aten::polygamma(int n, Tensor self) -> Tensor
static inline Tensor polygamma(int64_t n, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::polygamma(n, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::polygamma", "");
    return op.callUnboxed<Tensor, int64_t, const Tensor &>(n, self);
#endif
}

// aten::erfinv(Tensor self) -> Tensor
static inline Tensor erfinv(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::erfinv(self);
            break;
        default:
            AT_ERROR("erfinv not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::erfinv", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::erfinv.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & erfinv_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::erfinv_out_out(out, self);
            break;
        default:
            AT_ERROR("erfinv_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::erfinv", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::sign(Tensor self) -> Tensor
static inline Tensor sign(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sign(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sign", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::sign.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & sign_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sign_out_out(out, self);
            break;
        default:
            AT_ERROR("sign_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sign", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::dist(Tensor self, Tensor other, Scalar p=2) -> Tensor
static inline Tensor dist(const Tensor & self, const Tensor & other, Scalar p) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::dist(self, other, p);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::dist", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(self, other, p);
#endif
}

// aten::atan2.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & atan2_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::atan2_out_out(out, self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::atan2", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::atan2(Tensor self, Tensor other) -> Tensor
static inline Tensor atan2(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::atan2(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::atan2", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::lerp.Scalar_out(Tensor self, Tensor end, Scalar weight, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & lerp_out(Tensor & out, const Tensor & self, const Tensor & end, Scalar weight) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, end);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lerp_out_Scalar_out(out, self, end, weight);
            break;
        default:
            AT_ERROR("lerp_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lerp", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar>(out, self, end, weight);
#endif
}

// aten::lerp.Tensor_out(Tensor self, Tensor end, Tensor weight, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & lerp_out(Tensor & out, const Tensor & self, const Tensor & end, const Tensor & weight) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, end, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lerp_out_Tensor_out(out, self, end, weight);
            break;
        default:
            AT_ERROR("lerp_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lerp", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &>(out, self, end, weight);
#endif
}

// aten::lerp.Scalar(Tensor self, Tensor end, Scalar weight) -> Tensor
static inline Tensor lerp(const Tensor & self, const Tensor & end, Scalar weight) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, end);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lerp_Scalar(self, end, weight);
            break;
        default:
            AT_ERROR("lerp not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lerp", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(self, end, weight);
#endif
}

// aten::lerp.Tensor(Tensor self, Tensor end, Tensor weight) -> Tensor
static inline Tensor lerp(const Tensor & self, const Tensor & end, const Tensor & weight) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, end, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::lerp_Tensor(self, end, weight);
            break;
        default:
            AT_ERROR("lerp not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::lerp", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(self, end, weight);
#endif
}

// aten::histc.out(Tensor self, int bins=100, Scalar min=0, Scalar max=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & histc_out(Tensor & out, const Tensor & self, int64_t bins, Scalar min, Scalar max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::histc_out_out(out, self, bins, min, max);
            break;
        default:
            AT_ERROR("histc_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::histc", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t, Scalar, Scalar>(out, self, bins, min, max);
#endif
}

// aten::histc(Tensor self, int bins=100, Scalar min=0, Scalar max=0) -> Tensor
static inline Tensor histc(const Tensor & self, int64_t bins, Scalar min, Scalar max) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::histc(self, bins, min, max);
            break;
        default:
            AT_ERROR("histc not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::histc", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, Scalar, Scalar>(self, bins, min, max);
#endif
}

// aten::fmod.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & fmod_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fmod_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("fmod_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fmod", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::fmod.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor fmod(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fmod_Scalar(self, other);
            break;
        default:
            AT_ERROR("fmod not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fmod", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::fmod.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & fmod_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fmod_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("fmod_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fmod", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::fmod.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor fmod(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fmod_Tensor(self, other);
            break;
        default:
            AT_ERROR("fmod not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fmod", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::remainder.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & remainder_out(Tensor & out, const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::remainder_out_Scalar_out(out, self, other);
            break;
        default:
            AT_ERROR("remainder_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::remainder", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, other);
#endif
}

// aten::remainder.Scalar(Tensor self, Scalar other) -> Tensor
static inline Tensor remainder(const Tensor & self, Scalar other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::remainder_Scalar(self, other);
            break;
        default:
            AT_ERROR("remainder not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::remainder", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, other);
#endif
}

// aten::remainder.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & remainder_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::remainder_out_Tensor_out(out, self, other);
            break;
        default:
            AT_ERROR("remainder_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::remainder", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::remainder.Tensor(Tensor self, Tensor other) -> Tensor
static inline Tensor remainder(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::remainder_Tensor(self, other);
            break;
        default:
            AT_ERROR("remainder not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::remainder", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::min.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & min_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::min_out_out(out, self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::min.other(Tensor self, Tensor other) -> Tensor
static inline Tensor min(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::min_other(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min", "other");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::min(Tensor self) -> Tensor
static inline Tensor min(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::min(self);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::min(self);
            break;
        default:
            AT_ERROR("min not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::min", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::max.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & max_out(Tensor & out, const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_out_out(out, self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, other);
#endif
}

// aten::max.other(Tensor self, Tensor other) -> Tensor
static inline Tensor max(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::max_other(self, other);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max", "other");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::max(Tensor self) -> Tensor
static inline Tensor max(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max(self);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::max(self);
            break;
        default:
            AT_ERROR("max not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::median(Tensor self) -> Tensor
static inline Tensor median(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::median(self);
            break;
        default:
            AT_ERROR("median not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::median", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::sort.values(Tensor self, int dim=-1, bool descending=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> sort_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool descending) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(values, indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sort_out_values(values, indices, self, dim, descending);
            break;
        default:
            AT_ERROR("sort_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sort", "values");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, bool>(values, indices, self, dim, descending);
#endif
}

// aten::sort(Tensor self, int dim=-1, bool descending=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> sort(const Tensor & self, int64_t dim, bool descending) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sort(self, dim, descending);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::sort(self, dim, descending);
            break;
        default:
            AT_ERROR("sort not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sort", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, bool>(self, dim, descending);
#endif
}

// aten::sort.dimname_values(Tensor self, Dimname dim, bool descending=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
static inline std::tuple<Tensor &,Tensor &> sort_out(Tensor & values, Tensor & indices, const Tensor & self, Dimname dim, bool descending) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sort_out_dimname_values(values, indices, self, dim, descending);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sort", "dimname_values");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, Dimname, bool>(values, indices, self, dim, descending);
#endif
}

// aten::sort.dimname(Tensor self, Dimname dim, bool descending=False) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> sort(const Tensor & self, Dimname dim, bool descending) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sort_dimname(self, dim, descending);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sort", "dimname");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, Dimname, bool>(self, dim, descending);
#endif
}

// aten::argsort(Tensor self, int dim=-1, bool descending=False) -> Tensor
static inline Tensor argsort(const Tensor & self, int64_t dim, bool descending) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::argsort(self, dim, descending);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::argsort", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t, bool>(self, dim, descending);
#endif
}

// aten::argsort.dimname(Tensor self, Dimname dim, bool descending=False) -> Tensor
static inline Tensor argsort(const Tensor & self, Dimname dim, bool descending) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::argsort_dimname(self, dim, descending);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::argsort", "dimname");
    return op.callUnboxed<Tensor, const Tensor &, Dimname, bool>(self, dim, descending);
#endif
}

// aten::topk.values(Tensor self, int k, int dim=-1, bool largest=True, bool sorted=True, *, Tensor(a!) values, Tensor(b!) indices) ->(Tensor(a!) values, Tensor(b!) indices)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(values, indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::topk_out_values(values, indices, self, k, dim, largest, sorted);
            break;
        default:
            AT_ERROR("topk_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::topk", "values");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, int64_t, bool, bool>(values, indices, self, k, dim, largest, sorted);
#endif
}

// aten::topk(Tensor self, int k, int dim=-1, bool largest=True, bool sorted=True) -> (Tensor values, Tensor indices)
static inline std::tuple<Tensor,Tensor> topk(const Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::topk(self, k, dim, largest, sorted);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::topk(self, k, dim, largest, sorted);
            break;
        default:
            AT_ERROR("topk not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::topk", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, int64_t, bool, bool>(self, k, dim, largest, sorted);
#endif
}

// aten::all(Tensor self) -> Tensor
static inline Tensor all(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::all(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::all", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::any(Tensor self) -> Tensor
static inline Tensor any(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::any(self);
            break;
        default:
            AT_ERROR("any not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::any", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::renorm.out(Tensor self, Scalar p, int dim, Scalar maxnorm, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & renorm_out(Tensor & out, const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::renorm_out_out(out, self, p, dim, maxnorm);
            break;
        default:
            AT_ERROR("renorm_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::renorm", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar, int64_t, Scalar>(out, self, p, dim, maxnorm);
#endif
}

// aten::renorm(Tensor self, Scalar p, int dim, Scalar maxnorm) -> Tensor
static inline Tensor renorm(const Tensor & self, Scalar p, int64_t dim, Scalar maxnorm) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::renorm(self, p, dim, maxnorm);
            break;
        default:
            AT_ERROR("renorm not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::renorm", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, int64_t, Scalar>(self, p, dim, maxnorm);
#endif
}

// aten::equal(Tensor self, Tensor other) -> bool
static inline bool equal(const Tensor & self, const Tensor & other) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, other);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::equal(self, other);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::equal(self, other);
            break;
        default:
            AT_ERROR("equal not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::equal", "");
    return op.callUnboxed<bool, const Tensor &, const Tensor &>(self, other);
#endif
}

// aten::pow.Tensor_Tensor_out(Tensor self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & pow_out(Tensor & out, const Tensor & self, const Tensor & exponent) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, exponent);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::pow_out_Tensor_Tensor_out(out, self, exponent);
            break;
        default:
            AT_ERROR("pow_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pow", "Tensor_Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(out, self, exponent);
#endif
}

// aten::pow.Tensor_Tensor(Tensor self, Tensor exponent) -> Tensor
static inline Tensor pow(const Tensor & self, const Tensor & exponent) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, exponent);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::pow_Tensor_Tensor(self, exponent);
            break;
        default:
            AT_ERROR("pow not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pow", "Tensor_Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(self, exponent);
#endif
}

// aten::pow.Scalar_out(Scalar self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & pow_out(Tensor & out, Scalar self, const Tensor & exponent) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, exponent);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::pow_out_Scalar_out(out, self, exponent);
            break;
        default:
            AT_ERROR("pow_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pow", "Scalar_out");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, const Tensor &>(out, self, exponent);
#endif
}

// aten::pow.Scalar(Scalar self, Tensor exponent) -> Tensor
static inline Tensor pow(Scalar self, const Tensor & exponent) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(exponent);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::pow_Scalar(self, exponent);
            break;
        default:
            AT_ERROR("pow not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::pow", "Scalar");
    return op.callUnboxed<Tensor, Scalar, const Tensor &>(self, exponent);
#endif
}

// aten::normal.Tensor_float_out(Tensor mean, float std=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & normal_out(Tensor & out, const Tensor & mean, double std, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::normal_out_Tensor_float_out(out, mean, std, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::normal", "Tensor_float_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, double, c10::optional<Generator>>(out, mean, std, generator);
#endif
}

// aten::normal.Tensor_float(Tensor mean, float std=1, *, Generator? generator=None) -> Tensor
static inline Tensor normal(const Tensor & mean, double std, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::normal_Tensor_float(mean, std, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::normal", "Tensor_float");
    return op.callUnboxed<Tensor, const Tensor &, double, c10::optional<Generator>>(mean, std, generator);
#endif
}

// aten::normal.float_Tensor_out(float mean, Tensor std, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & normal_out(Tensor & out, double mean, const Tensor & std, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::normal_out_float_Tensor_out(out, mean, std, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::normal", "float_Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, double, const Tensor &, c10::optional<Generator>>(out, mean, std, generator);
#endif
}

// aten::normal.float_Tensor(float mean, Tensor std, *, Generator? generator=None) -> Tensor
static inline Tensor normal(double mean, const Tensor & std, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::normal_float_Tensor(mean, std, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::normal", "float_Tensor");
    return op.callUnboxed<Tensor, double, const Tensor &, c10::optional<Generator>>(mean, std, generator);
#endif
}

// aten::normal.Tensor_Tensor_out(Tensor mean, Tensor std, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & normal_out(Tensor & out, const Tensor & mean, const Tensor & std, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::normal_out_Tensor_Tensor_out(out, mean, std, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::normal", "Tensor_Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, c10::optional<Generator>>(out, mean, std, generator);
#endif
}

// aten::normal.Tensor_Tensor(Tensor mean, Tensor std, *, Generator? generator=None) -> Tensor
static inline Tensor normal(const Tensor & mean, const Tensor & std, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::normal_Tensor_Tensor(mean, std, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::normal", "Tensor_Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, c10::optional<Generator>>(mean, std, generator);
#endif
}

// aten::normal.float_float(float mean, float std, int[] size, *, Generator? generator=None, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
static inline Tensor normal(double mean, double std, IntArrayRef size, c10::optional<Generator> generator, const TensorOptions & options) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::normal_float_float(mean, std, size, generator, options);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::normal", "float_float");
    return op.callUnboxed<Tensor, double, double, IntArrayRef, c10::optional<Generator>, const TensorOptions &>(mean, std, size, generator, options);
#endif
}

// aten::normal.float_float_out(float mean, float std, int[] size, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & normal_out(Tensor & out, double mean, double std, IntArrayRef size, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::normal_out_float_float_out(out, mean, std, size, generator);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::normal", "float_float_out");
    return op.callUnboxed<Tensor &, Tensor &, double, double, IntArrayRef, c10::optional<Generator>>(out, mean, std, size, generator);
#endif
}

// aten::alias(Tensor(a) self) -> Tensor(a)
static inline Tensor alias(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::alias(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::alias", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::_addr(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
static inline Tensor _addr(const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, vec1, vec2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_addr(self, vec1, vec2, beta, alpha);
            break;
        default:
            AT_ERROR("_addr not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_addr", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, vec1, vec2, beta, alpha);
#endif
}

// aten::_addr_(Tensor(a!) self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!)
static inline Tensor & _addr_(Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, vec1, vec2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_addr_(self, vec1, vec2, beta, alpha);
            break;
        default:
            AT_ERROR("_addr_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_addr_", "");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(self, vec1, vec2, beta, alpha);
#endif
}

// aten::_addr.out(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & _addr_out(Tensor & out, const Tensor & self, const Tensor & vec1, const Tensor & vec2, Scalar beta, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, vec1, vec2);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_addr_out_out(out, self, vec1, vec2, beta, alpha);
            break;
        default:
            AT_ERROR("_addr_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_addr", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(out, self, vec1, vec2, beta, alpha);
#endif
}

// aten::_index_copy_(Tensor(a!) self, int dim, Tensor index, Tensor source) -> Tensor(a!)
static inline Tensor & _index_copy_(Tensor & self, int64_t dim, const Tensor & index, const Tensor & source) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, index, source);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_index_copy_(self, dim, index, source);
            break;
        default:
            AT_ERROR("_index_copy_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_index_copy_", "");
    return op.callUnboxed<Tensor &, Tensor &, int64_t, const Tensor &, const Tensor &>(self, dim, index, source);
#endif
}

// aten::_cumsum(Tensor self, int dim) -> Tensor
static inline Tensor _cumsum(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_cumsum(self, dim);
            break;
        default:
            AT_ERROR("_cumsum not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cumsum", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::_cumsum.out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & _cumsum_out(Tensor & out, const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_cumsum_out_out(out, self, dim);
            break;
        default:
            AT_ERROR("_cumsum_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cumsum", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t>(out, self, dim);
#endif
}

// aten::_cumprod(Tensor self, int dim) -> Tensor
static inline Tensor _cumprod(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_cumprod(self, dim);
            break;
        default:
            AT_ERROR("_cumprod not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cumprod", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::_cumprod.out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & _cumprod_out(Tensor & out, const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_cumprod_out_out(out, self, dim);
            break;
        default:
            AT_ERROR("_cumprod_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cumprod", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t>(out, self, dim);
#endif
}

// aten::_var(Tensor self, bool unbiased=True) -> Tensor
static inline Tensor _var(const Tensor & self, bool unbiased) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_var(self, unbiased);
            break;
        default:
            AT_ERROR("_var not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_var", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, unbiased);
#endif
}

// aten::_std(Tensor self, bool unbiased=True) -> Tensor
static inline Tensor _std(const Tensor & self, bool unbiased) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_std(self, unbiased);
            break;
        default:
            AT_ERROR("_std not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_std", "");
    return op.callUnboxed<Tensor, const Tensor &, bool>(self, unbiased);
#endif
}

// aten::_amp_non_finite_check_and_unscale_(Tensor(a!) self, Tensor(b!) found_inf, Tensor inv_scale) -> ()
static inline void _amp_non_finite_check_and_unscale_(Tensor & self, Tensor & found_inf, const Tensor & inv_scale) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, found_inf, inv_scale);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_amp_non_finite_check_and_unscale_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_amp_non_finite_check_and_unscale_", "");
    return op.callUnboxed<void, Tensor &, Tensor &, const Tensor &>(self, found_inf, inv_scale);
#endif
}

// aten::_amp_update_scale(Tensor(a!) growth_tracker, Tensor current_scale, Tensor found_inf, float scale_growth_factor, float scale_backoff_factor, int growth_interval) -> Tensor
static inline Tensor _amp_update_scale(Tensor & growth_tracker, const Tensor & current_scale, const Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(growth_tracker, current_scale, found_inf);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("_amp_update_scale not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_amp_update_scale", "");
    return op.callUnboxed<Tensor, Tensor &, const Tensor &, const Tensor &, double, double, int64_t>(growth_tracker, current_scale, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval);
#endif
}

// aten::_cat(Tensor[] tensors, int dim=0) -> Tensor
static inline Tensor _cat(TensorList tensors, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(tensors);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_cat(tensors, dim);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::_cat(tensors, dim);
            break;
        default:
            AT_ERROR("_cat not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cat", "");
    return op.callUnboxed<Tensor, TensorList, int64_t>(tensors, dim);
#endif
}

// aten::_cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & _cat_out(Tensor & out, TensorList tensors, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, tensors);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_cat_out_out(out, tensors, dim);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::_cat_out_out(out, tensors, dim);
            break;
        default:
            AT_ERROR("_cat_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_cat", "out");
    return op.callUnboxed<Tensor &, Tensor &, TensorList, int64_t>(out, tensors, dim);
#endif
}

// aten::_mode(Tensor self, int dim=-1, bool keepdim=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _mode(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_mode(self, dim, keepdim);
            break;
        default:
            AT_ERROR("_mode not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_mode", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::_mode.values(Tensor self, int dim=-1, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> _mode_out(Tensor & values, Tensor & indices, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(values, indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_mode_out_values(values, indices, self, dim, keepdim);
            break;
        default:
            AT_ERROR("_mode_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_mode", "values");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, bool>(values, indices, self, dim, keepdim);
#endif
}

// aten::_max(Tensor self, int dim, bool keepdim=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _max(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_max(self, dim, keepdim);
            break;
        default:
            AT_ERROR("_max not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_max", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::_max.max(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) max, Tensor(b!) max_indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> _max_out(Tensor & max, Tensor & max_indices, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(max, max_indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_max_out_max(max, max_indices, self, dim, keepdim);
            break;
        default:
            AT_ERROR("_max_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_max", "max");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, bool>(max, max_indices, self, dim, keepdim);
#endif
}

// aten::_min(Tensor self, int dim, bool keepdim=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> _min(const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_min(self, dim, keepdim);
            break;
        default:
            AT_ERROR("_min not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_min", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, int64_t, bool>(self, dim, keepdim);
#endif
}

// aten::_min.min(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) min, Tensor(b!) min_indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> _min_out(Tensor & min, Tensor & min_indices, const Tensor & self, int64_t dim, bool keepdim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(min, min_indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_min_out_min(min, min_indices, self, dim, keepdim);
            break;
        default:
            AT_ERROR("_min_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_min", "min");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, int64_t, bool>(min, min_indices, self, dim, keepdim);
#endif
}

// aten::bucketize.Tensor(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False) -> Tensor
static inline Tensor bucketize(const Tensor & self, const Tensor & boundaries, bool out_int32, bool right) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, boundaries);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bucketize_Tensor(self, boundaries, out_int32, right);
            break;
        default:
            AT_ERROR("bucketize not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bucketize", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, bool, bool>(self, boundaries, out_int32, right);
#endif
}

// aten::bucketize.Tensor_out(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & bucketize_out(Tensor & out, const Tensor & self, const Tensor & boundaries, bool out_int32, bool right) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, boundaries);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bucketize_out_Tensor_out(out, self, boundaries, out_int32, right);
            break;
        default:
            AT_ERROR("bucketize_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bucketize", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, bool, bool>(out, self, boundaries, out_int32, right);
#endif
}

// aten::bucketize.Scalar(Scalar self, Tensor boundaries, *, bool out_int32=False, bool right=False) -> Tensor
static inline Tensor bucketize(Scalar self, const Tensor & boundaries, bool out_int32, bool right) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(boundaries);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::bucketize_Scalar(self, boundaries, out_int32, right);
            break;
        default:
            AT_ERROR("bucketize not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::bucketize", "Scalar");
    return op.callUnboxed<Tensor, Scalar, const Tensor &, bool, bool>(self, boundaries, out_int32, right);
#endif
}

// aten::searchsorted.Tensor(Tensor sorted_sequence, Tensor self, *, bool out_int32=False, bool right=False) -> Tensor
static inline Tensor searchsorted(const Tensor & sorted_sequence, const Tensor & self, bool out_int32, bool right) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(sorted_sequence, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::searchsorted_Tensor(sorted_sequence, self, out_int32, right);
            break;
        default:
            AT_ERROR("searchsorted not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::searchsorted", "Tensor");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, bool, bool>(sorted_sequence, self, out_int32, right);
#endif
}

// aten::searchsorted.Tensor_out(Tensor sorted_sequence, Tensor self, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & searchsorted_out(Tensor & out, const Tensor & sorted_sequence, const Tensor & self, bool out_int32, bool right) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, sorted_sequence, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::searchsorted_out_Tensor_out(out, sorted_sequence, self, out_int32, right);
            break;
        default:
            AT_ERROR("searchsorted_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::searchsorted", "Tensor_out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, bool, bool>(out, sorted_sequence, self, out_int32, right);
#endif
}

// aten::searchsorted.Scalar(Tensor sorted_sequence, Scalar self, *, bool out_int32=False, bool right=False) -> Tensor
static inline Tensor searchsorted(const Tensor & sorted_sequence, Scalar self, bool out_int32, bool right) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(sorted_sequence);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::searchsorted_Scalar(sorted_sequence, self, out_int32, right);
            break;
        default:
            AT_ERROR("searchsorted not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::searchsorted", "Scalar");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, bool, bool>(sorted_sequence, self, out_int32, right);
#endif
}

// aten::mse_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & mse_loss_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mse_loss_out_out(out, self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mse_loss", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, int64_t>(out, self, target, reduction);
#endif
}

// aten::mse_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor
static inline Tensor mse_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::mse_loss(self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mse_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(self, target, reduction);
#endif
}

// aten::mse_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & mse_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mse_loss_backward_out_grad_input(grad_input, grad_output, self, target, reduction);
            break;
        default:
            AT_ERROR("mse_loss_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mse_loss_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_input, grad_output, self, target, reduction);
#endif
}

// aten::mse_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction) -> Tensor
static inline Tensor mse_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::mse_loss_backward(grad_output, self, target, reduction);
            break;
        default:
            AT_ERROR("mse_loss_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mse_loss_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_output, self, target, reduction);
#endif
}

// aten::l1_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & l1_loss_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::l1_loss_out_out(out, self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::l1_loss", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, int64_t>(out, self, target, reduction);
#endif
}

// aten::l1_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor
static inline Tensor l1_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::l1_loss(self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::l1_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(self, target, reduction);
#endif
}

// aten::l1_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::l1_loss_backward_out_grad_input(grad_input, grad_output, self, target, reduction);
            break;
        default:
            AT_ERROR("l1_loss_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::l1_loss_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_input, grad_output, self, target, reduction);
#endif
}

// aten::l1_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction) -> Tensor
static inline Tensor l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::l1_loss_backward(grad_output, self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::l1_loss_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_output, self, target, reduction);
#endif
}

// aten::multi_margin_loss.out(Tensor self, Tensor target, Scalar p=1, Scalar margin=1, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & multi_margin_loss_out(Tensor & out, const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multi_margin_loss_out_out(out, self, target, p, margin, weight, reduction);
            break;
        default:
            AT_ERROR("multi_margin_loss_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multi_margin_loss", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, const Tensor &, int64_t>(out, self, target, p, margin, weight, reduction);
#endif
}

// aten::multi_margin_loss(Tensor self, Tensor target, Scalar p=1, Scalar margin=1, Tensor? weight=None, int reduction=Mean) -> Tensor
static inline Tensor multi_margin_loss(const Tensor & self, const Tensor & target, Scalar p, Scalar margin, const Tensor & weight, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multi_margin_loss(self, target, p, margin, weight, reduction);
            break;
        default:
            AT_ERROR("multi_margin_loss not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multi_margin_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar, Scalar, const Tensor &, int64_t>(self, target, p, margin, weight, reduction);
#endif
}

// aten::multi_margin_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Scalar p, Scalar margin, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multi_margin_loss_backward_out_grad_input(grad_input, grad_output, self, target, p, margin, weight, reduction);
            break;
        default:
            AT_ERROR("multi_margin_loss_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multi_margin_loss_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, const Tensor &, int64_t>(grad_input, grad_output, self, target, p, margin, weight, reduction);
#endif
}

// aten::multi_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, Scalar p, Scalar margin, Tensor? weight=None, int reduction=Mean) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multi_margin_loss_backward(grad_output, self, target, p, margin, weight, reduction);
            break;
        default:
            AT_ERROR("multi_margin_loss_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multi_margin_loss_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, const Tensor &, int64_t>(grad_output, self, target, p, margin, weight, reduction);
#endif
}

// aten::multilabel_margin_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & multilabel_margin_loss_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::multilabel_margin_loss_out_out(out, self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multilabel_margin_loss", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, int64_t>(out, self, target, reduction);
#endif
}

// aten::multilabel_margin_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor
static inline Tensor multilabel_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::multilabel_margin_loss(self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multilabel_margin_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(self, target, reduction);
#endif
}

// aten::multilabel_margin_loss_forward.output(Tensor self, Tensor target, int reduction, *, Tensor(a!) output, Tensor(b!) is_target) -> (Tensor(a!), Tensor(b!))
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(output, is_target, self, target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multilabel_margin_loss_forward_out_output(output, is_target, self, target, reduction);
            break;
        default:
            AT_ERROR("multilabel_margin_loss_forward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multilabel_margin_loss_forward", "output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, const Tensor &, int64_t>(output, is_target, self, target, reduction);
#endif
}

// aten::multilabel_margin_loss_forward(Tensor self, Tensor target, int reduction) -> (Tensor output, Tensor is_target)
static inline std::tuple<Tensor,Tensor> multilabel_margin_loss_forward(const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multilabel_margin_loss_forward(self, target, reduction);
            break;
        default:
            AT_ERROR("multilabel_margin_loss_forward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multilabel_margin_loss_forward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, int64_t>(self, target, reduction);
#endif
}

// aten::multilabel_margin_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, Tensor is_target, *, Tensor(a!) grad_input) -> Tensor(a!)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, target, is_target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multilabel_margin_loss_backward_out_grad_input(grad_input, grad_output, self, target, reduction, is_target);
            break;
        default:
            AT_ERROR("multilabel_margin_loss_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multilabel_margin_loss_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, const Tensor &>(grad_input, grad_output, self, target, reduction, is_target);
#endif
}

// aten::multilabel_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction, Tensor is_target) -> Tensor
static inline Tensor multilabel_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction, const Tensor & is_target) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, target, is_target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::multilabel_margin_loss_backward(grad_output, self, target, reduction, is_target);
            break;
        default:
            AT_ERROR("multilabel_margin_loss_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::multilabel_margin_loss_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t, const Tensor &>(grad_output, self, target, reduction, is_target);
#endif
}

// aten::nll_loss.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, int ignore_index=-100, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & nll_loss_out(Tensor & out, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nll_loss_out_out(out, self, target, weight, reduction, ignore_index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t>(out, self, target, weight, reduction, ignore_index);
#endif
}

// aten::nll_loss(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, int ignore_index=-100) -> Tensor
static inline Tensor nll_loss(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nll_loss(self, target, weight, reduction, ignore_index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t>(self, target, weight, reduction, ignore_index);
#endif
}

// aten::nll_loss_forward.output(Tensor self, Tensor target, Tensor? weight, int reduction, int ignore_index, *, Tensor(a!) output, Tensor(b!) total_weight) -> (Tensor(a!), Tensor(b!))
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(output, total_weight, self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nll_loss_forward_out_output(output, total_weight, self, target, weight, reduction, ignore_index);
            break;
        default:
            AT_ERROR("nll_loss_forward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss_forward", "output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t>(output, total_weight, self, target, weight, reduction, ignore_index);
#endif
}

// aten::nll_loss_forward(Tensor self, Tensor target, Tensor? weight, int reduction, int ignore_index) -> (Tensor output, Tensor total_weight)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nll_loss_forward(self, target, weight, reduction, ignore_index);
            break;
        default:
            AT_ERROR("nll_loss_forward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss_forward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t>(self, target, weight, reduction, ignore_index);
#endif
}

// aten::nll_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight, int reduction, int ignore_index, Tensor total_weight, *, Tensor(a!) grad_input) -> Tensor(a!)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, target, weight, total_weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nll_loss_backward_out_grad_input(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight);
            break;
        default:
            AT_ERROR("nll_loss_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, const Tensor &>(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight);
#endif
}

// aten::nll_loss_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight, int reduction, int ignore_index, Tensor total_weight) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, target, weight, total_weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nll_loss_backward(grad_output, self, target, weight, reduction, ignore_index, total_weight);
            break;
        default:
            AT_ERROR("nll_loss_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, const Tensor &>(grad_output, self, target, weight, reduction, ignore_index, total_weight);
#endif
}

// aten::nll_loss2d.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, int ignore_index=-100, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & nll_loss2d_out(Tensor & out, const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nll_loss2d_out_out(out, self, target, weight, reduction, ignore_index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t>(out, self, target, weight, reduction, ignore_index);
#endif
}

// aten::nll_loss2d(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, int ignore_index=-100) -> Tensor
static inline Tensor nll_loss2d(const Tensor & self, const Tensor & target, const Tensor & weight, int64_t reduction, int64_t ignore_index) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::nll_loss2d(self, target, weight, reduction, ignore_index);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss2d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t>(self, target, weight, reduction, ignore_index);
#endif
}

// aten::nll_loss2d_forward.output(Tensor self, Tensor target, Tensor? weight, int reduction, int ignore_index, *, Tensor(a!) output, Tensor(b!) total_weight) -> (Tensor(a!), Tensor(b!))
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(output, total_weight, self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nll_loss2d_forward_out_output(output, total_weight, self, target, weight, reduction, ignore_index);
            break;
        default:
            AT_ERROR("nll_loss2d_forward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss2d_forward", "output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t>(output, total_weight, self, target, weight, reduction, ignore_index);
#endif
}

// aten::nll_loss2d_forward(Tensor self, Tensor target, Tensor? weight, int reduction, int ignore_index) -> (Tensor output, Tensor total_weight)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, target, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nll_loss2d_forward(self, target, weight, reduction, ignore_index);
            break;
        default:
            AT_ERROR("nll_loss2d_forward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss2d_forward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t>(self, target, weight, reduction, ignore_index);
#endif
}

// aten::nll_loss2d_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight, int reduction, int ignore_index, Tensor total_weight, *, Tensor(a!) grad_input) -> Tensor(a!)
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, target, weight, total_weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nll_loss2d_backward_out_grad_input(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight);
            break;
        default:
            AT_ERROR("nll_loss2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, const Tensor &>(grad_input, grad_output, self, target, weight, reduction, ignore_index, total_weight);
#endif
}

// aten::nll_loss2d_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight, int reduction, int ignore_index, Tensor total_weight) -> Tensor
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) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, target, weight, total_weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::nll_loss2d_backward(grad_output, self, target, weight, reduction, ignore_index, total_weight);
            break;
        default:
            AT_ERROR("nll_loss2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::nll_loss2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t, int64_t, const Tensor &>(grad_output, self, target, weight, reduction, ignore_index, total_weight);
#endif
}

// aten::smooth_l1_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & smooth_l1_loss_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::smooth_l1_loss_out_out(out, self, target, reduction);
            break;
        default:
            AT_ERROR("smooth_l1_loss_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::smooth_l1_loss", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, int64_t>(out, self, target, reduction);
#endif
}

// aten::smooth_l1_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor
static inline Tensor smooth_l1_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::smooth_l1_loss(self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::smooth_l1_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(self, target, reduction);
#endif
}

// aten::smooth_l1_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & smooth_l1_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, target);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::smooth_l1_loss_backward_out_grad_input(grad_input, grad_output, self, target, reduction);
            break;
        default:
            AT_ERROR("smooth_l1_loss_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::smooth_l1_loss_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_input, grad_output, self, target, reduction);
#endif
}

// aten::smooth_l1_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction) -> Tensor
static inline Tensor smooth_l1_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::smooth_l1_loss_backward(grad_output, self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::smooth_l1_loss_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_output, self, target, reduction);
#endif
}

// aten::soft_margin_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & soft_margin_loss_out(Tensor & out, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::soft_margin_loss_out_out(out, self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::soft_margin_loss", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, int64_t>(out, self, target, reduction);
#endif
}

// aten::soft_margin_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor
static inline Tensor soft_margin_loss(const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::soft_margin_loss(self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::soft_margin_loss", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(self, target, reduction);
#endif
}

// aten::soft_margin_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & soft_margin_loss_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::soft_margin_loss_backward_out_grad_input(grad_input, grad_output, self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::soft_margin_loss_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_input, grad_output, self, target, reduction);
#endif
}

// aten::soft_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction) -> Tensor
static inline Tensor soft_margin_loss_backward(const Tensor & grad_output, const Tensor & self, const Tensor & target, int64_t reduction) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::soft_margin_loss_backward(grad_output, self, target, reduction);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::soft_margin_loss_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, int64_t>(grad_output, self, target, reduction);
#endif
}

// aten::elu.out(Tensor self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & elu_out(Tensor & out, const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::elu_out_out(out, self, alpha, scale, input_scale);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::elu_out_out(out, self, alpha, scale, input_scale);
            break;
        default:
            AT_ERROR("elu_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::elu", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar, Scalar, Scalar>(out, self, alpha, scale, input_scale);
#endif
}

// aten::elu(Tensor self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1) -> Tensor
static inline Tensor elu(const Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::elu(self, alpha, scale, input_scale);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::elu(self, alpha, scale, input_scale);
            break;
        default:
            AT_ERROR("elu not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::elu", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar, Scalar>(self, alpha, scale, input_scale);
#endif
}

// aten::elu_backward.grad_input(Tensor grad_output, Scalar alpha, Scalar scale, Scalar input_scale, Tensor output, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & elu_backward_out(Tensor & grad_input, const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::elu_backward_out_grad_input(grad_input, grad_output, alpha, scale, input_scale, output);
            break;
        default:
            AT_ERROR("elu_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::elu_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar, Scalar, Scalar, const Tensor &>(grad_input, grad_output, alpha, scale, input_scale, output);
#endif
}

// aten::elu_backward(Tensor grad_output, Scalar alpha, Scalar scale, Scalar input_scale, Tensor output) -> Tensor
static inline Tensor elu_backward(const Tensor & grad_output, Scalar alpha, Scalar scale, Scalar input_scale, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::elu_backward(grad_output, alpha, scale, input_scale, output);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::elu_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar, Scalar, const Tensor &>(grad_output, alpha, scale, input_scale, output);
#endif
}

// aten::elu_(Tensor(a!) self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1) -> Tensor(a!)
static inline Tensor & elu_(Tensor & self, Scalar alpha, Scalar scale, Scalar input_scale) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::elu_(self, alpha, scale, input_scale);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::elu_(self, alpha, scale, input_scale);
            break;
        default:
            AT_ERROR("elu_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::elu_", "");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, Scalar, Scalar>(self, alpha, scale, input_scale);
#endif
}

// aten::glu.out(Tensor self, int dim=-1, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & glu_out(Tensor & out, const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::glu_out_out(out, self, dim);
            break;
        default:
            AT_ERROR("glu_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::glu", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, int64_t>(out, self, dim);
#endif
}

// aten::glu(Tensor self, int dim=-1) -> Tensor
static inline Tensor glu(const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::glu(self, dim);
            break;
        default:
            AT_ERROR("glu not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::glu", "");
    return op.callUnboxed<Tensor, const Tensor &, int64_t>(self, dim);
#endif
}

// aten::glu_backward.grad_input(Tensor grad_output, Tensor self, int dim, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & glu_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::glu_backward_out_grad_input(grad_input, grad_output, self, dim);
            break;
        default:
            AT_ERROR("glu_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::glu_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, int64_t>(grad_input, grad_output, self, dim);
#endif
}

// aten::glu_backward(Tensor grad_output, Tensor self, int dim) -> Tensor
static inline Tensor glu_backward(const Tensor & grad_output, const Tensor & self, int64_t dim) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::glu_backward(grad_output, self, dim);
            break;
        default:
            AT_ERROR("glu_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::glu_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, int64_t>(grad_output, self, dim);
#endif
}

// aten::hardsigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & hardsigmoid_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hardsigmoid_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardsigmoid", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::hardsigmoid(Tensor self) -> Tensor
static inline Tensor hardsigmoid(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::hardsigmoid(self);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::hardsigmoid(self);
            break;
        default:
            AT_ERROR("hardsigmoid not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardsigmoid", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::hardsigmoid_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & hardsigmoid_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hardsigmoid_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardsigmoid_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::hardsigmoid_backward(Tensor grad_output, Tensor self) -> Tensor
static inline Tensor hardsigmoid_backward(const Tensor & grad_output, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::hardsigmoid_backward(grad_output, self);
            break;
        default:
            AT_ERROR("hardsigmoid_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardsigmoid_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad_output, self);
#endif
}

// aten::hardtanh.out(Tensor self, Scalar min_val=-1, Scalar max_val=1, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & hardtanh_out(Tensor & out, const Tensor & self, Scalar min_val, Scalar max_val) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::hardtanh_out_out(out, self, min_val, max_val);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::hardtanh_out_out(out, self, min_val, max_val);
            break;
        default:
            AT_ERROR("hardtanh_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardtanh", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar, Scalar>(out, self, min_val, max_val);
#endif
}

// aten::hardtanh(Tensor self, Scalar min_val=-1, Scalar max_val=1) -> Tensor
static inline Tensor hardtanh(const Tensor & self, Scalar min_val, Scalar max_val) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::hardtanh(self, min_val, max_val);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::hardtanh(self, min_val, max_val);
            break;
        default:
            AT_ERROR("hardtanh not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardtanh", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar>(self, min_val, max_val);
#endif
}

// aten::hardtanh_backward.grad_input(Tensor grad_output, Tensor self, Scalar min_val, Scalar max_val, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & hardtanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::hardtanh_backward_out_grad_input(grad_input, grad_output, self, min_val, max_val);
            break;
        default:
            AT_ERROR("hardtanh_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardtanh_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar, Scalar>(grad_input, grad_output, self, min_val, max_val);
#endif
}

// aten::hardtanh_backward(Tensor grad_output, Tensor self, Scalar min_val, Scalar max_val) -> Tensor
static inline Tensor hardtanh_backward(const Tensor & grad_output, const Tensor & self, Scalar min_val, Scalar max_val) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hardtanh_backward(grad_output, self, min_val, max_val);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardtanh_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar, Scalar>(grad_output, self, min_val, max_val);
#endif
}

// aten::hardtanh_(Tensor(a!) self, Scalar min_val=-1, Scalar max_val=1) -> Tensor(a!)
static inline Tensor & hardtanh_(Tensor & self, Scalar min_val, Scalar max_val) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::hardtanh_(self, min_val, max_val);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::hardtanh_(self, min_val, max_val);
            break;
        default:
            AT_ERROR("hardtanh_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardtanh_", "");
    return op.callUnboxed<Tensor &, Tensor &, Scalar, Scalar>(self, min_val, max_val);
#endif
}

// aten::hardswish.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & hardswish_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::hardswish_out_out(out, self);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::hardswish_out_out(out, self);
            break;
        default:
            AT_ERROR("hardswish_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardswish", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::hardswish(Tensor self) -> Tensor
static inline Tensor hardswish(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hardswish(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardswish", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::hardswish_(Tensor(a!) self) -> Tensor(a!)
static inline Tensor & hardswish_(Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::hardswish_(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardswish_", "");
    return op.callUnboxed<Tensor &, Tensor &>(self);
#endif
}

// aten::hardswish_backward(Tensor grad_output, Tensor self) -> Tensor
static inline Tensor hardswish_backward(const Tensor & grad_output, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::hardswish_backward(grad_output, self);
            break;
        default:
            AT_ERROR("hardswish_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::hardswish_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad_output, self);
#endif
}

// aten::leaky_relu.out(Tensor self, Scalar negative_slope=0.01, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & leaky_relu_out(Tensor & out, const Tensor & self, Scalar negative_slope) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::leaky_relu_out_out(out, self, negative_slope);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::leaky_relu_out_out(out, self, negative_slope);
            break;
        default:
            AT_ERROR("leaky_relu_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::leaky_relu", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, negative_slope);
#endif
}

// aten::leaky_relu(Tensor self, Scalar negative_slope=0.01) -> Tensor
static inline Tensor leaky_relu(const Tensor & self, Scalar negative_slope) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::leaky_relu(self, negative_slope);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::leaky_relu(self, negative_slope);
            break;
        default:
            AT_ERROR("leaky_relu not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::leaky_relu", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, negative_slope);
#endif
}

// aten::leaky_relu_backward(Tensor grad_output, Tensor self, Scalar negative_slope, bool self_is_result) -> Tensor
static inline Tensor leaky_relu_backward(const Tensor & grad_output, const Tensor & self, Scalar negative_slope, bool self_is_result) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::leaky_relu_backward(grad_output, self, negative_slope, self_is_result);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::leaky_relu_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar, bool>(grad_output, self, negative_slope, self_is_result);
#endif
}

// aten::leaky_relu_(Tensor(a!) self, Scalar negative_slope=0.01) -> Tensor(a!)
static inline Tensor & leaky_relu_(Tensor & self, Scalar negative_slope) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::leaky_relu_(self, negative_slope);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::leaky_relu_(self, negative_slope);
            break;
        default:
            AT_ERROR("leaky_relu_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::leaky_relu_", "");
    return op.callUnboxed<Tensor &, Tensor &, Scalar>(self, negative_slope);
#endif
}

// aten::log_sigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & log_sigmoid_out(Tensor & out, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log_sigmoid_out_out(out, self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_sigmoid", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &>(out, self);
#endif
}

// aten::log_sigmoid(Tensor self) -> Tensor
static inline Tensor log_sigmoid(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::log_sigmoid(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_sigmoid", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::log_sigmoid_forward.output(Tensor self, *, Tensor(a!) output, Tensor(b!) buffer) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> log_sigmoid_forward_out(Tensor & output, Tensor & buffer, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(output, buffer, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log_sigmoid_forward_out_output(output, buffer, self);
            break;
        default:
            AT_ERROR("log_sigmoid_forward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_sigmoid_forward", "output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &>(output, buffer, self);
#endif
}

// aten::log_sigmoid_forward(Tensor self) -> (Tensor output, Tensor buffer)
static inline std::tuple<Tensor,Tensor> log_sigmoid_forward(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log_sigmoid_forward(self);
            break;
        default:
            AT_ERROR("log_sigmoid_forward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_sigmoid_forward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &>(self);
#endif
}

// aten::log_sigmoid_backward.grad_input(Tensor grad_output, Tensor self, Tensor buffer, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & log_sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & buffer) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, buffer);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log_sigmoid_backward_out_grad_input(grad_input, grad_output, self, buffer);
            break;
        default:
            AT_ERROR("log_sigmoid_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_sigmoid_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &>(grad_input, grad_output, self, buffer);
#endif
}

// aten::log_sigmoid_backward(Tensor grad_output, Tensor self, Tensor buffer) -> Tensor
static inline Tensor log_sigmoid_backward(const Tensor & grad_output, const Tensor & self, const Tensor & buffer) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, buffer);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::log_sigmoid_backward(grad_output, self, buffer);
            break;
        default:
            AT_ERROR("log_sigmoid_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::log_sigmoid_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(grad_output, self, buffer);
#endif
}

// aten::rrelu_with_noise.out(Tensor self, Tensor noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & rrelu_with_noise_out(Tensor & out, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, noise);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::rrelu_with_noise_out_out(out, self, noise, lower, upper, training, generator);
            break;
        default:
            AT_ERROR("rrelu_with_noise_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rrelu_with_noise", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, bool, c10::optional<Generator>>(out, self, noise, lower, upper, training, generator);
#endif
}

// aten::rrelu_with_noise(Tensor self, Tensor noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None) -> Tensor
static inline Tensor rrelu_with_noise(const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, noise);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::rrelu_with_noise(self, noise, lower, upper, training, generator);
            break;
        default:
            AT_ERROR("rrelu_with_noise not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rrelu_with_noise", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar, Scalar, bool, c10::optional<Generator>>(self, noise, lower, upper, training, generator);
#endif
}

// aten::rrelu_with_noise_backward(Tensor grad_output, Tensor self, Tensor noise, Scalar lower, Scalar upper, bool training, bool self_is_result) -> Tensor
static inline Tensor rrelu_with_noise_backward(const Tensor & grad_output, const Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, bool self_is_result) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::rrelu_with_noise_backward(grad_output, self, noise, lower, upper, training, self_is_result);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rrelu_with_noise_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, bool, bool>(grad_output, self, noise, lower, upper, training, self_is_result);
#endif
}

// aten::rrelu_with_noise_(Tensor(a!) self, Tensor noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None) -> Tensor(a!)
static inline Tensor & rrelu_with_noise_(Tensor & self, const Tensor & noise, Scalar lower, Scalar upper, bool training, c10::optional<Generator> generator) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, noise);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::rrelu_with_noise_(self, noise, lower, upper, training, generator);
            break;
        default:
            AT_ERROR("rrelu_with_noise_ not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::rrelu_with_noise_", "");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar, Scalar, bool, c10::optional<Generator>>(self, noise, lower, upper, training, generator);
#endif
}

// aten::softplus.out(Tensor self, Scalar beta=1, Scalar threshold=20, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & softplus_out(Tensor & out, const Tensor & self, Scalar beta, Scalar threshold) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::softplus_out_out(out, self, beta, threshold);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softplus", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar, Scalar>(out, self, beta, threshold);
#endif
}

// aten::softplus(Tensor self, Scalar beta=1, Scalar threshold=20) -> Tensor
static inline Tensor softplus(const Tensor & self, Scalar beta, Scalar threshold) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::softplus(self, beta, threshold);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softplus", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar, Scalar>(self, beta, threshold);
#endif
}

// aten::softplus_backward.grad_input(Tensor grad_output, Tensor self, Scalar beta, Scalar threshold, Tensor output, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & softplus_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::softplus_backward_out_grad_input(grad_input, grad_output, self, beta, threshold, output);
            break;
        default:
            AT_ERROR("softplus_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softplus_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar, Scalar, const Tensor &>(grad_input, grad_output, self, beta, threshold, output);
#endif
}

// aten::softplus_backward(Tensor grad_output, Tensor self, Scalar beta, Scalar threshold, Tensor output) -> Tensor
static inline Tensor softplus_backward(const Tensor & grad_output, const Tensor & self, Scalar beta, Scalar threshold, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::softplus_backward(grad_output, self, beta, threshold, output);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softplus_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar, Scalar, const Tensor &>(grad_output, self, beta, threshold, output);
#endif
}

// aten::softshrink.out(Tensor self, Scalar lambd=0.5, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & softshrink_out(Tensor & out, const Tensor & self, Scalar lambd) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::softshrink_out_out(out, self, lambd);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softshrink", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, Scalar>(out, self, lambd);
#endif
}

// aten::softshrink(Tensor self, Scalar lambd=0.5) -> Tensor
static inline Tensor softshrink(const Tensor & self, Scalar lambd) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::softshrink(self, lambd);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softshrink", "");
    return op.callUnboxed<Tensor, const Tensor &, Scalar>(self, lambd);
#endif
}

// aten::softshrink_backward.grad_input(Tensor grad_output, Tensor self, Scalar lambd, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & softshrink_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, Scalar lambd) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::softshrink_backward_out_grad_input(grad_input, grad_output, self, lambd);
            break;
        default:
            AT_ERROR("softshrink_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softshrink_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, Scalar>(grad_input, grad_output, self, lambd);
#endif
}

// aten::softshrink_backward(Tensor grad_output, Tensor self, Scalar lambd) -> Tensor
static inline Tensor softshrink_backward(const Tensor & grad_output, const Tensor & self, Scalar lambd) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::softshrink_backward(grad_output, self, lambd);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::softshrink_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(grad_output, self, lambd);
#endif
}

// aten::adaptive_avg_pool2d.out(Tensor self, int[2] output_size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & adaptive_avg_pool2d_out(Tensor & out, const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_avg_pool2d_out_out(out, self, output_size);
            break;
        default:
            AT_ERROR("adaptive_avg_pool2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_avg_pool2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, self, output_size);
#endif
}

// aten::adaptive_avg_pool2d(Tensor self, int[2] output_size) -> Tensor
static inline Tensor adaptive_avg_pool2d(const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::adaptive_avg_pool2d(self, output_size);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_avg_pool2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, output_size);
#endif
}

// aten::mkldnn_adaptive_avg_pool2d(Tensor self, int[2] output_size) -> Tensor
static inline Tensor mkldnn_adaptive_avg_pool2d(const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("mkldnn_adaptive_avg_pool2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::mkldnn_adaptive_avg_pool2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, output_size);
#endif
}

// aten::_adaptive_avg_pool2d(Tensor self, int[2] output_size) -> Tensor
static inline Tensor _adaptive_avg_pool2d(const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_adaptive_avg_pool2d(self, output_size);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::_adaptive_avg_pool2d(self, output_size);
            break;
        default:
            AT_ERROR("_adaptive_avg_pool2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_adaptive_avg_pool2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, output_size);
#endif
}

// aten::_adaptive_avg_pool2d_backward(Tensor grad_output, Tensor self) -> Tensor
static inline Tensor _adaptive_avg_pool2d_backward(const Tensor & grad_output, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::_adaptive_avg_pool2d_backward(grad_output, self);
            break;
        default:
            AT_ERROR("_adaptive_avg_pool2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_adaptive_avg_pool2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad_output, self);
#endif
}

// aten::adaptive_avg_pool3d.out(Tensor self, int[3] output_size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & adaptive_avg_pool3d_out(Tensor & out, const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_avg_pool3d_out_out(out, self, output_size);
            break;
        default:
            AT_ERROR("adaptive_avg_pool3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_avg_pool3d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, self, output_size);
#endif
}

// aten::adaptive_avg_pool3d(Tensor self, int[3] output_size) -> Tensor
static inline Tensor adaptive_avg_pool3d(const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_avg_pool3d(self, output_size);
            break;
        default:
            AT_ERROR("adaptive_avg_pool3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_avg_pool3d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, output_size);
#endif
}

// aten::adaptive_avg_pool3d_backward.grad_input(Tensor grad_output, Tensor self, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & adaptive_avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_avg_pool3d_backward_out_grad_input(grad_input, grad_output, self);
            break;
        default:
            AT_ERROR("adaptive_avg_pool3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_avg_pool3d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(grad_input, grad_output, self);
#endif
}

// aten::adaptive_avg_pool3d_backward(Tensor grad_output, Tensor self) -> Tensor
static inline Tensor adaptive_avg_pool3d_backward(const Tensor & grad_output, const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_avg_pool3d_backward(grad_output, self);
            break;
        default:
            AT_ERROR("adaptive_avg_pool3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_avg_pool3d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad_output, self);
#endif
}

// aten::adaptive_max_pool2d.out(Tensor self, int[2] output_size, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> adaptive_max_pool2d_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_max_pool2d_out_out(out, indices, self, output_size);
            break;
        default:
            AT_ERROR("adaptive_max_pool2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool2d", "out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, indices, self, output_size);
#endif
}

// aten::adaptive_max_pool2d(Tensor self, int[2] output_size) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> adaptive_max_pool2d(const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_max_pool2d(self, output_size);
            break;
        default:
            AT_ERROR("adaptive_max_pool2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool2d", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef>(self, output_size);
#endif
}

// aten::adaptive_max_pool2d_backward.grad_input(Tensor grad_output, Tensor self, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & adaptive_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_max_pool2d_backward_out_grad_input(grad_input, grad_output, self, indices);
            break;
        default:
            AT_ERROR("adaptive_max_pool2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &>(grad_input, grad_output, self, indices);
#endif
}

// aten::adaptive_max_pool2d_backward(Tensor grad_output, Tensor self, Tensor indices) -> Tensor
static inline Tensor adaptive_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_max_pool2d_backward(grad_output, self, indices);
            break;
        default:
            AT_ERROR("adaptive_max_pool2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(grad_output, self, indices);
#endif
}

// aten::adaptive_max_pool3d.out(Tensor self, int[3] output_size, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> adaptive_max_pool3d_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_max_pool3d_out_out(out, indices, self, output_size);
            break;
        default:
            AT_ERROR("adaptive_max_pool3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool3d", "out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, indices, self, output_size);
#endif
}

// aten::adaptive_max_pool3d(Tensor self, int[3] output_size) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> adaptive_max_pool3d(const Tensor & self, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_max_pool3d(self, output_size);
            break;
        default:
            AT_ERROR("adaptive_max_pool3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool3d", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef>(self, output_size);
#endif
}

// aten::adaptive_max_pool3d_backward.grad_input(Tensor grad_output, Tensor self, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & adaptive_max_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_max_pool3d_backward_out_grad_input(grad_input, grad_output, self, indices);
            break;
        default:
            AT_ERROR("adaptive_max_pool3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool3d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &>(grad_input, grad_output, self, indices);
#endif
}

// aten::adaptive_max_pool3d_backward(Tensor grad_output, Tensor self, Tensor indices) -> Tensor
static inline Tensor adaptive_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::adaptive_max_pool3d_backward(grad_output, self, indices);
            break;
        default:
            AT_ERROR("adaptive_max_pool3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::adaptive_max_pool3d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &>(grad_output, self, indices);
#endif
}

// aten::avg_pool2d.out(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & avg_pool2d_out(Tensor & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::avg_pool2d_out_out(out, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        default:
            AT_ERROR("avg_pool2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool, c10::optional<int64_t>>(out, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
#endif
}

// aten::avg_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None) -> Tensor
static inline Tensor avg_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        default:
            AT_ERROR("avg_pool2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool, c10::optional<int64_t>>(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
#endif
}

// aten::avg_pool2d_backward.grad_input(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride, int[2] padding, bool ceil_mode, bool count_include_pad, int? divisor_override, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & avg_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::avg_pool2d_backward_out_grad_input(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        default:
            AT_ERROR("avg_pool2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool, c10::optional<int64_t>>(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
#endif
}

// aten::avg_pool2d_backward(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride, int[2] padding, bool ceil_mode, bool count_include_pad, int? divisor_override) -> Tensor
static inline Tensor avg_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::avg_pool2d_backward(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        default:
            AT_ERROR("avg_pool2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool, c10::optional<int64_t>>(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
#endif
}

// aten::avg_pool3d.out(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & avg_pool3d_out(Tensor & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::avg_pool3d_out_out(out, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        default:
            AT_ERROR("avg_pool3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool3d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool, c10::optional<int64_t>>(out, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
#endif
}

// aten::avg_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None) -> Tensor
static inline Tensor avg_pool3d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        default:
            AT_ERROR("avg_pool3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool3d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool, c10::optional<int64_t>>(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
#endif
}

// aten::avg_pool3d_backward.grad_input(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, bool ceil_mode, bool count_include_pad, int? divisor_override, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & avg_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::avg_pool3d_backward_out_grad_input(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        default:
            AT_ERROR("avg_pool3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool3d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool, c10::optional<int64_t>>(grad_input, grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
#endif
}

// aten::avg_pool3d_backward(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, bool ceil_mode, bool count_include_pad, int? divisor_override) -> Tensor
static inline Tensor avg_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::avg_pool3d_backward(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
            break;
        default:
            AT_ERROR("avg_pool3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::avg_pool3d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, bool, bool, c10::optional<int64_t>>(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
#endif
}

// aten::fractional_max_pool2d.output(Tensor self, int[2] kernel_size, int[2] output_size, Tensor random_samples, *, Tensor(a!) output, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> fractional_max_pool2d_out(Tensor & output, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(output, indices, self, random_samples);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fractional_max_pool2d_out_output(output, indices, self, kernel_size, output_size, random_samples);
            break;
        default:
            AT_ERROR("fractional_max_pool2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fractional_max_pool2d", "output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &>(output, indices, self, kernel_size, output_size, random_samples);
#endif
}

// aten::fractional_max_pool2d(Tensor self, int[2] kernel_size, int[2] output_size, Tensor random_samples) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> fractional_max_pool2d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, random_samples);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fractional_max_pool2d(self, kernel_size, output_size, random_samples);
            break;
        default:
            AT_ERROR("fractional_max_pool2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fractional_max_pool2d", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &>(self, kernel_size, output_size, random_samples);
#endif
}

// aten::fractional_max_pool2d_backward.grad_input(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] output_size, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & fractional_max_pool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fractional_max_pool2d_backward_out_grad_input(grad_input, grad_output, self, kernel_size, output_size, indices);
            break;
        default:
            AT_ERROR("fractional_max_pool2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fractional_max_pool2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &>(grad_input, grad_output, self, kernel_size, output_size, indices);
#endif
}

// aten::fractional_max_pool2d_backward(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] output_size, Tensor indices) -> Tensor
static inline Tensor fractional_max_pool2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fractional_max_pool2d_backward(grad_output, self, kernel_size, output_size, indices);
            break;
        default:
            AT_ERROR("fractional_max_pool2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fractional_max_pool2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &>(grad_output, self, kernel_size, output_size, indices);
#endif
}

// aten::fractional_max_pool3d.output(Tensor self, int[3] kernel_size, int[3] output_size, Tensor random_samples, *, Tensor(a!) output, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> fractional_max_pool3d_out(Tensor & output, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(output, indices, self, random_samples);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fractional_max_pool3d_out_output(output, indices, self, kernel_size, output_size, random_samples);
            break;
        default:
            AT_ERROR("fractional_max_pool3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fractional_max_pool3d", "output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &>(output, indices, self, kernel_size, output_size, random_samples);
#endif
}

// aten::fractional_max_pool3d(Tensor self, int[3] kernel_size, int[3] output_size, Tensor random_samples) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> fractional_max_pool3d(const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & random_samples) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, random_samples);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fractional_max_pool3d(self, kernel_size, output_size, random_samples);
            break;
        default:
            AT_ERROR("fractional_max_pool3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fractional_max_pool3d", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &>(self, kernel_size, output_size, random_samples);
#endif
}

// aten::fractional_max_pool3d_backward.grad_input(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] output_size, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & fractional_max_pool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fractional_max_pool3d_backward_out_grad_input(grad_input, grad_output, self, kernel_size, output_size, indices);
            break;
        default:
            AT_ERROR("fractional_max_pool3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fractional_max_pool3d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &>(grad_input, grad_output, self, kernel_size, output_size, indices);
#endif
}

// aten::fractional_max_pool3d_backward(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] output_size, Tensor indices) -> Tensor
static inline Tensor fractional_max_pool3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::fractional_max_pool3d_backward(grad_output, self, kernel_size, output_size, indices);
            break;
        default:
            AT_ERROR("fractional_max_pool3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::fractional_max_pool3d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, const Tensor &>(grad_output, self, kernel_size, output_size, indices);
#endif
}

// aten::max_pool2d_with_indices.out(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> max_pool2d_with_indices_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_pool2d_with_indices_out_out(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
            break;
        default:
            AT_ERROR("max_pool2d_with_indices_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool2d_with_indices", "out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::max_pool2d_with_indices(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> max_pool2d_with_indices(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_pool2d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
            break;
        default:
            AT_ERROR("max_pool2d_with_indices not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool2d_with_indices", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::max_pool2d_with_indices_backward.grad_input(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride, int[2] padding, int[2] dilation, bool ceil_mode, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & max_pool2d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_pool2d_with_indices_backward_out_grad_input(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
            break;
        default:
            AT_ERROR("max_pool2d_with_indices_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool2d_with_indices_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool, const Tensor &>(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
#endif
}

// aten::max_pool2d_with_indices_backward(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride, int[2] padding, int[2] dilation, bool ceil_mode, Tensor indices) -> Tensor
static inline Tensor max_pool2d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_pool2d_with_indices_backward(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
            break;
        default:
            AT_ERROR("max_pool2d_with_indices_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool2d_with_indices_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool, const Tensor &>(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
#endif
}

// aten::max_pool3d_with_indices.out(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!))
static inline std::tuple<Tensor &,Tensor &> max_pool3d_with_indices_out(Tensor & out, Tensor & indices, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, indices, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_pool3d_with_indices_out_out(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
            break;
        default:
            AT_ERROR("max_pool3d_with_indices_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool3d_with_indices", "out");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::max_pool3d_with_indices(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> (Tensor, Tensor)
static inline std::tuple<Tensor,Tensor> max_pool3d_with_indices(const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_pool3d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
            break;
        default:
            AT_ERROR("max_pool3d_with_indices not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool3d_with_indices", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool>(self, kernel_size, stride, padding, dilation, ceil_mode);
#endif
}

// aten::max_pool3d_with_indices_backward.grad_input(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, int[3] dilation, bool ceil_mode, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & max_pool3d_with_indices_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_pool3d_with_indices_backward_out_grad_input(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
            break;
        default:
            AT_ERROR("max_pool3d_with_indices_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool3d_with_indices_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool, const Tensor &>(grad_input, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
#endif
}

// aten::max_pool3d_with_indices_backward(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, int[3] dilation, bool ceil_mode, Tensor indices) -> Tensor
static inline Tensor max_pool3d_with_indices_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, const Tensor & indices) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_pool3d_with_indices_backward(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
            break;
        default:
            AT_ERROR("max_pool3d_with_indices_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_pool3d_with_indices_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, bool, const Tensor &>(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices);
#endif
}

// aten::max_unpool2d.out(Tensor self, Tensor indices, int[2] output_size, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & max_unpool2d_out(Tensor & out, const Tensor & self, const Tensor & indices, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_unpool2d_out_out(out, self, indices, output_size);
            break;
        default:
            AT_ERROR("max_unpool2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_unpool2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef>(out, self, indices, output_size);
#endif
}

// aten::max_unpool2d(Tensor self, Tensor indices, int[2] output_size) -> Tensor
static inline Tensor max_unpool2d(const Tensor & self, const Tensor & indices, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_unpool2d(self, indices, output_size);
            break;
        default:
            AT_ERROR("max_unpool2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_unpool2d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef>(self, indices, output_size);
#endif
}

// aten::max_unpool2d_backward.grad_input(Tensor grad_output, Tensor self, Tensor indices, int[2] output_size, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & max_unpool2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_unpool2d_backward_out_grad_input(grad_input, grad_output, self, indices, output_size);
            break;
        default:
            AT_ERROR("max_unpool2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_unpool2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, IntArrayRef>(grad_input, grad_output, self, indices, output_size);
#endif
}

// aten::max_unpool2d_backward(Tensor grad_output, Tensor self, Tensor indices, int[2] output_size) -> Tensor
static inline Tensor max_unpool2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_unpool2d_backward(grad_output, self, indices, output_size);
            break;
        default:
            AT_ERROR("max_unpool2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_unpool2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef>(grad_output, self, indices, output_size);
#endif
}

// aten::max_unpool3d.out(Tensor self, Tensor indices, int[3] output_size, int[3] stride, int[3] padding, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & max_unpool3d_out(Tensor & out, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_unpool3d_out_out(out, self, indices, output_size, stride, padding);
            break;
        default:
            AT_ERROR("max_unpool3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_unpool3d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(out, self, indices, output_size, stride, padding);
#endif
}

// aten::max_unpool3d(Tensor self, Tensor indices, int[3] output_size, int[3] stride, int[3] padding) -> Tensor
static inline Tensor max_unpool3d(const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_unpool3d(self, indices, output_size, stride, padding);
            break;
        default:
            AT_ERROR("max_unpool3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_unpool3d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(self, indices, output_size, stride, padding);
#endif
}

// aten::max_unpool3d_backward.grad_input(Tensor grad_output, Tensor self, Tensor indices, int[3] output_size, int[3] stride, int[3] padding, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & max_unpool3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_unpool3d_backward_out_grad_input(grad_input, grad_output, self, indices, output_size, stride, padding);
            break;
        default:
            AT_ERROR("max_unpool3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_unpool3d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(grad_input, grad_output, self, indices, output_size, stride, padding);
#endif
}

// aten::max_unpool3d_backward(Tensor grad_output, Tensor self, Tensor indices, int[3] output_size, int[3] stride, int[3] padding) -> Tensor
static inline Tensor max_unpool3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, indices);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::max_unpool3d_backward(grad_output, self, indices, output_size, stride, padding);
            break;
        default:
            AT_ERROR("max_unpool3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::max_unpool3d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(grad_output, self, indices, output_size, stride, padding);
#endif
}

// aten::reflection_pad1d.out(Tensor self, int[2] padding, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & reflection_pad1d_out(Tensor & out, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::reflection_pad1d_out_out(out, self, padding);
            break;
        default:
            AT_ERROR("reflection_pad1d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reflection_pad1d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, self, padding);
#endif
}

// aten::reflection_pad1d(Tensor self, int[2] padding) -> Tensor
static inline Tensor reflection_pad1d(const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::reflection_pad1d(self, padding);
            break;
        default:
            AT_ERROR("reflection_pad1d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reflection_pad1d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, padding);
#endif
}

// aten::reflection_pad1d_backward.grad_input(Tensor grad_output, Tensor self, int[2] padding, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & reflection_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::reflection_pad1d_backward_out_grad_input(grad_input, grad_output, self, padding);
            break;
        default:
            AT_ERROR("reflection_pad1d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reflection_pad1d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef>(grad_input, grad_output, self, padding);
#endif
}

// aten::reflection_pad1d_backward(Tensor grad_output, Tensor self, int[2] padding) -> Tensor
static inline Tensor reflection_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::reflection_pad1d_backward(grad_output, self, padding);
            break;
        default:
            AT_ERROR("reflection_pad1d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reflection_pad1d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef>(grad_output, self, padding);
#endif
}

// aten::reflection_pad2d.out(Tensor self, int[4] padding, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & reflection_pad2d_out(Tensor & out, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::reflection_pad2d_out_out(out, self, padding);
            break;
        default:
            AT_ERROR("reflection_pad2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reflection_pad2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, self, padding);
#endif
}

// aten::reflection_pad2d(Tensor self, int[4] padding) -> Tensor
static inline Tensor reflection_pad2d(const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::reflection_pad2d(self, padding);
            break;
        default:
            AT_ERROR("reflection_pad2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reflection_pad2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, padding);
#endif
}

// aten::reflection_pad2d_backward.grad_input(Tensor grad_output, Tensor self, int[4] padding, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & reflection_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::reflection_pad2d_backward_out_grad_input(grad_input, grad_output, self, padding);
            break;
        default:
            AT_ERROR("reflection_pad2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reflection_pad2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef>(grad_input, grad_output, self, padding);
#endif
}

// aten::reflection_pad2d_backward(Tensor grad_output, Tensor self, int[4] padding) -> Tensor
static inline Tensor reflection_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::reflection_pad2d_backward(grad_output, self, padding);
            break;
        default:
            AT_ERROR("reflection_pad2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::reflection_pad2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef>(grad_output, self, padding);
#endif
}

// aten::replication_pad1d.out(Tensor self, int[2] padding, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & replication_pad1d_out(Tensor & out, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad1d_out_out(out, self, padding);
            break;
        default:
            AT_ERROR("replication_pad1d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad1d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, self, padding);
#endif
}

// aten::replication_pad1d(Tensor self, int[2] padding) -> Tensor
static inline Tensor replication_pad1d(const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad1d(self, padding);
            break;
        default:
            AT_ERROR("replication_pad1d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad1d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, padding);
#endif
}

// aten::replication_pad1d_backward.grad_input(Tensor grad_output, Tensor self, int[2] padding, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & replication_pad1d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad1d_backward_out_grad_input(grad_input, grad_output, self, padding);
            break;
        default:
            AT_ERROR("replication_pad1d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad1d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef>(grad_input, grad_output, self, padding);
#endif
}

// aten::replication_pad1d_backward(Tensor grad_output, Tensor self, int[2] padding) -> Tensor
static inline Tensor replication_pad1d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad1d_backward(grad_output, self, padding);
            break;
        default:
            AT_ERROR("replication_pad1d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad1d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef>(grad_output, self, padding);
#endif
}

// aten::replication_pad2d.out(Tensor self, int[4] padding, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & replication_pad2d_out(Tensor & out, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad2d_out_out(out, self, padding);
            break;
        default:
            AT_ERROR("replication_pad2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, self, padding);
#endif
}

// aten::replication_pad2d(Tensor self, int[4] padding) -> Tensor
static inline Tensor replication_pad2d(const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad2d(self, padding);
            break;
        default:
            AT_ERROR("replication_pad2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, padding);
#endif
}

// aten::replication_pad2d_backward.grad_input(Tensor grad_output, Tensor self, int[4] padding, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & replication_pad2d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad2d_backward_out_grad_input(grad_input, grad_output, self, padding);
            break;
        default:
            AT_ERROR("replication_pad2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef>(grad_input, grad_output, self, padding);
#endif
}

// aten::replication_pad2d_backward(Tensor grad_output, Tensor self, int[4] padding) -> Tensor
static inline Tensor replication_pad2d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad2d_backward(grad_output, self, padding);
            break;
        default:
            AT_ERROR("replication_pad2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef>(grad_output, self, padding);
#endif
}

// aten::replication_pad3d.out(Tensor self, int[6] padding, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & replication_pad3d_out(Tensor & out, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad3d_out_out(out, self, padding);
            break;
        default:
            AT_ERROR("replication_pad3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad3d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef>(out, self, padding);
#endif
}

// aten::replication_pad3d(Tensor self, int[6] padding) -> Tensor
static inline Tensor replication_pad3d(const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad3d(self, padding);
            break;
        default:
            AT_ERROR("replication_pad3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad3d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef>(self, padding);
#endif
}

// aten::replication_pad3d_backward.grad_input(Tensor grad_output, Tensor self, int[6] padding, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & replication_pad3d_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad3d_backward_out_grad_input(grad_input, grad_output, self, padding);
            break;
        default:
            AT_ERROR("replication_pad3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad3d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef>(grad_input, grad_output, self, padding);
#endif
}

// aten::replication_pad3d_backward(Tensor grad_output, Tensor self, int[6] padding) -> Tensor
static inline Tensor replication_pad3d_backward(const Tensor & grad_output, const Tensor & self, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::replication_pad3d_backward(grad_output, self, padding);
            break;
        default:
            AT_ERROR("replication_pad3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::replication_pad3d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef>(grad_output, self, padding);
#endif
}

// aten::upsample_linear1d.out(Tensor self, int[1] output_size, bool align_corners, float? scales=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & upsample_linear1d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_linear1d_out_out(out, self, output_size, align_corners, scales);
            break;
        default:
            AT_ERROR("upsample_linear1d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_linear1d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool, c10::optional<double>>(out, self, output_size, align_corners, scales);
#endif
}

// aten::upsample_linear1d(Tensor self, int[1] output_size, bool align_corners, float? scales=None) -> Tensor
static inline Tensor upsample_linear1d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_linear1d(self, output_size, align_corners, scales);
            break;
        default:
            AT_ERROR("upsample_linear1d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_linear1d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool, c10::optional<double>>(self, output_size, align_corners, scales);
#endif
}

// aten::upsample_linear1d_backward.grad_input(Tensor grad_output, int[1] output_size, int[3] input_size, bool align_corners, float? scales=None, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & upsample_linear1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_linear1d_backward_out_grad_input(grad_input, grad_output, output_size, input_size, align_corners, scales);
            break;
        default:
            AT_ERROR("upsample_linear1d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_linear1d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, bool, c10::optional<double>>(grad_input, grad_output, output_size, input_size, align_corners, scales);
#endif
}

// aten::upsample_linear1d_backward(Tensor grad_output, int[1] output_size, int[3] input_size, bool align_corners, float? scales=None) -> Tensor
static inline Tensor upsample_linear1d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_linear1d_backward(grad_output, output_size, input_size, align_corners, scales);
            break;
        default:
            AT_ERROR("upsample_linear1d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_linear1d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, bool, c10::optional<double>>(grad_output, output_size, input_size, align_corners, scales);
#endif
}

// aten::upsample_bilinear2d.out(Tensor self, int[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & upsample_bilinear2d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_bilinear2d_out_out(out, self, output_size, align_corners, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_bilinear2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_bilinear2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool, c10::optional<double>, c10::optional<double>>(out, self, output_size, align_corners, scales_h, scales_w);
#endif
}

// aten::upsample_bilinear2d(Tensor self, int[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_bilinear2d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_bilinear2d(self, output_size, align_corners, scales_h, scales_w);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::upsample_bilinear2d(self, output_size, align_corners, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_bilinear2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_bilinear2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool, c10::optional<double>, c10::optional<double>>(self, output_size, align_corners, scales_h, scales_w);
#endif
}

// aten::upsample_bilinear2d_backward.grad_input(Tensor grad_output, int[2] output_size, int[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & upsample_bilinear2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_bilinear2d_backward_out_grad_input(grad_input, grad_output, output_size, input_size, align_corners, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_bilinear2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_bilinear2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, bool, c10::optional<double>, c10::optional<double>>(grad_input, grad_output, output_size, input_size, align_corners, scales_h, scales_w);
#endif
}

// aten::upsample_bilinear2d_backward(Tensor grad_output, int[2] output_size, int[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_bilinear2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_bilinear2d_backward(grad_output, output_size, input_size, align_corners, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_bilinear2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_bilinear2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, bool, c10::optional<double>, c10::optional<double>>(grad_output, output_size, input_size, align_corners, scales_h, scales_w);
#endif
}

// aten::upsample_bicubic2d.out(Tensor self, int[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & upsample_bicubic2d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_bicubic2d_out_out(out, self, output_size, align_corners, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_bicubic2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_bicubic2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool, c10::optional<double>, c10::optional<double>>(out, self, output_size, align_corners, scales_h, scales_w);
#endif
}

// aten::upsample_bicubic2d(Tensor self, int[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_bicubic2d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_bicubic2d(self, output_size, align_corners, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_bicubic2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_bicubic2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool, c10::optional<double>, c10::optional<double>>(self, output_size, align_corners, scales_h, scales_w);
#endif
}

// aten::upsample_bicubic2d_backward.grad_input(Tensor grad_output, int[2] output_size, int[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & upsample_bicubic2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_bicubic2d_backward_out_grad_input(grad_input, grad_output, output_size, input_size, align_corners, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_bicubic2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_bicubic2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, bool, c10::optional<double>, c10::optional<double>>(grad_input, grad_output, output_size, input_size, align_corners, scales_h, scales_w);
#endif
}

// aten::upsample_bicubic2d_backward(Tensor grad_output, int[2] output_size, int[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_bicubic2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_bicubic2d_backward(grad_output, output_size, input_size, align_corners, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_bicubic2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_bicubic2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, bool, c10::optional<double>, c10::optional<double>>(grad_output, output_size, input_size, align_corners, scales_h, scales_w);
#endif
}

// aten::upsample_trilinear3d.out(Tensor self, int[3] output_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & upsample_trilinear3d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_trilinear3d_out_out(out, self, output_size, align_corners, scales_d, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_trilinear3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_trilinear3d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, bool, c10::optional<double>, c10::optional<double>, c10::optional<double>>(out, self, output_size, align_corners, scales_d, scales_h, scales_w);
#endif
}

// aten::upsample_trilinear3d(Tensor self, int[3] output_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_trilinear3d(const Tensor & self, IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_trilinear3d(self, output_size, align_corners, scales_d, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_trilinear3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_trilinear3d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, bool, c10::optional<double>, c10::optional<double>, c10::optional<double>>(self, output_size, align_corners, scales_d, scales_h, scales_w);
#endif
}

// aten::upsample_trilinear3d_backward.grad_input(Tensor grad_output, int[3] output_size, int[5] input_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & upsample_trilinear3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_trilinear3d_backward_out_grad_input(grad_input, grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_trilinear3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_trilinear3d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, bool, c10::optional<double>, c10::optional<double>, c10::optional<double>>(grad_input, grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w);
#endif
}

// aten::upsample_trilinear3d_backward(Tensor grad_output, int[3] output_size, int[5] input_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_trilinear3d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_trilinear3d_backward(grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_trilinear3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_trilinear3d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, bool, c10::optional<double>, c10::optional<double>, c10::optional<double>>(grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w);
#endif
}

// aten::upsample_nearest1d.out(Tensor self, int[1] output_size, float? scales=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & upsample_nearest1d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest1d_out_out(out, self, output_size, scales);
            break;
        default:
            AT_ERROR("upsample_nearest1d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest1d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, c10::optional<double>>(out, self, output_size, scales);
#endif
}

// aten::upsample_nearest1d(Tensor self, int[1] output_size, float? scales=None) -> Tensor
static inline Tensor upsample_nearest1d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest1d(self, output_size, scales);
            break;
        default:
            AT_ERROR("upsample_nearest1d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest1d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, c10::optional<double>>(self, output_size, scales);
#endif
}

// aten::upsample_nearest1d_backward.grad_input(Tensor grad_output, int[1] output_size, int[3] input_size, float? scales=None, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & upsample_nearest1d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest1d_backward_out_grad_input(grad_input, grad_output, output_size, input_size, scales);
            break;
        default:
            AT_ERROR("upsample_nearest1d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest1d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, c10::optional<double>>(grad_input, grad_output, output_size, input_size, scales);
#endif
}

// aten::upsample_nearest1d_backward(Tensor grad_output, int[1] output_size, int[3] input_size, float? scales=None) -> Tensor
static inline Tensor upsample_nearest1d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest1d_backward(grad_output, output_size, input_size, scales);
            break;
        default:
            AT_ERROR("upsample_nearest1d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest1d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, c10::optional<double>>(grad_output, output_size, input_size, scales);
#endif
}

// aten::upsample_nearest2d.out(Tensor self, int[2] output_size, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & upsample_nearest2d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest2d_out_out(out, self, output_size, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_nearest2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, c10::optional<double>, c10::optional<double>>(out, self, output_size, scales_h, scales_w);
#endif
}

// aten::upsample_nearest2d(Tensor self, int[2] output_size, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_nearest2d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest2d(self, output_size, scales_h, scales_w);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::upsample_nearest2d(self, output_size, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_nearest2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest2d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, c10::optional<double>, c10::optional<double>>(self, output_size, scales_h, scales_w);
#endif
}

// aten::upsample_nearest2d_backward.grad_input(Tensor grad_output, int[2] output_size, int[4] input_size, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & upsample_nearest2d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest2d_backward_out_grad_input(grad_input, grad_output, output_size, input_size, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_nearest2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest2d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, c10::optional<double>, c10::optional<double>>(grad_input, grad_output, output_size, input_size, scales_h, scales_w);
#endif
}

// aten::upsample_nearest2d_backward(Tensor grad_output, int[2] output_size, int[4] input_size, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_nearest2d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest2d_backward(grad_output, output_size, input_size, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_nearest2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest2d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, c10::optional<double>, c10::optional<double>>(grad_output, output_size, input_size, scales_h, scales_w);
#endif
}

// aten::upsample_nearest3d.out(Tensor self, int[3] output_size, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & upsample_nearest3d_out(Tensor & out, const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest3d_out_out(out, self, output_size, scales_d, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_nearest3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest3d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, c10::optional<double>, c10::optional<double>, c10::optional<double>>(out, self, output_size, scales_d, scales_h, scales_w);
#endif
}

// aten::upsample_nearest3d(Tensor self, int[3] output_size, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_nearest3d(const Tensor & self, IntArrayRef output_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest3d(self, output_size, scales_d, scales_h, scales_w);
            break;
        case Backend::QuantizedCPU:
            return QuantizedCPUType::upsample_nearest3d(self, output_size, scales_d, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_nearest3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest3d", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, c10::optional<double>, c10::optional<double>, c10::optional<double>>(self, output_size, scales_d, scales_h, scales_w);
#endif
}

// aten::upsample_nearest3d_backward.grad_input(Tensor grad_output, int[3] output_size, int[5] input_size, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & upsample_nearest3d_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest3d_backward_out_grad_input(grad_input, grad_output, output_size, input_size, scales_d, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_nearest3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest3d_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, c10::optional<double>, c10::optional<double>, c10::optional<double>>(grad_input, grad_output, output_size, input_size, scales_d, scales_h, scales_w);
#endif
}

// aten::upsample_nearest3d_backward(Tensor grad_output, int[3] output_size, int[5] input_size, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor
static inline Tensor upsample_nearest3d_backward(const Tensor & grad_output, IntArrayRef output_size, IntArrayRef input_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::upsample_nearest3d_backward(grad_output, output_size, input_size, scales_d, scales_h, scales_w);
            break;
        default:
            AT_ERROR("upsample_nearest3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::upsample_nearest3d_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, c10::optional<double>, c10::optional<double>, c10::optional<double>>(grad_output, output_size, input_size, scales_d, scales_h, scales_w);
#endif
}

// aten::sigmoid_backward.grad_input(Tensor grad_output, Tensor output, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & sigmoid_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::sigmoid_backward_out_grad_input(grad_input, grad_output, output);
            break;
        default:
            AT_ERROR("sigmoid_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sigmoid_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(grad_input, grad_output, output);
#endif
}

// aten::sigmoid_backward(Tensor grad_output, Tensor output) -> Tensor
static inline Tensor sigmoid_backward(const Tensor & grad_output, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::sigmoid_backward(grad_output, output);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::sigmoid_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad_output, output);
#endif
}

// aten::tanh_backward.grad_input(Tensor grad_output, Tensor output, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & tanh_backward_out(Tensor & grad_input, const Tensor & grad_output, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output, output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::tanh_backward_out_grad_input(grad_input, grad_output, output);
            break;
        default:
            AT_ERROR("tanh_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tanh_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &>(grad_input, grad_output, output);
#endif
}

// aten::tanh_backward(Tensor grad_output, Tensor output) -> Tensor
static inline Tensor tanh_backward(const Tensor & grad_output, const Tensor & output) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::tanh_backward(grad_output, output);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::tanh_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &>(grad_output, output);
#endif
}

// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] output_padding=0, int[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & slow_conv_transpose2d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_transpose2d_out_out(out, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
            break;
        default:
            AT_ERROR("slow_conv_transpose2d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_transpose2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(out, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
#endif
}

// aten::slow_conv_transpose2d(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] output_padding=0, int[2] dilation=1) -> Tensor
static inline Tensor slow_conv_transpose2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_transpose2d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
            break;
        default:
            AT_ERROR("slow_conv_transpose2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_transpose2d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
#endif
}

// aten::slow_conv_transpose2d_backward.grad_output(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, int[2] output_padding, int[2] dilation, Tensor columns, Tensor ones, *, Tensor(a!)? grad_input, Tensor(b!)? grad_weight, Tensor(c!)? grad_bias) -> (Tensor(a!), Tensor(b!), Tensor(c!))
static inline std::tuple<Tensor &,Tensor &,Tensor &> slow_conv_transpose2d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & columns, const Tensor & ones) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_weight, grad_bias, grad_output, self, weight, columns, ones);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_transpose2d_backward_out_grad_output(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, columns, ones);
            break;
        default:
            AT_ERROR("slow_conv_transpose2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_transpose2d_backward", "grad_output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &,Tensor &>, Tensor &, Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &>(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, columns, ones);
#endif
}

// aten::slow_conv_transpose2d_backward.output_mask(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, int[2] output_padding, int[2] dilation, Tensor columns, Tensor ones, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias)
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv_transpose2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & columns, const Tensor & ones, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, weight, columns, ones);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_transpose2d_backward_output_mask(grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, columns, ones, output_mask);
            break;
        default:
            AT_ERROR("slow_conv_transpose2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_transpose2d_backward", "output_mask");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &, std::array<bool,3>>(grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, columns, ones, output_mask);
#endif
}

// aten::slow_conv_transpose3d.out(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, int[3] padding=0, int[3] output_padding=0, int[3] dilation=1, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & slow_conv_transpose3d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_transpose3d_out_out(out, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
            break;
        default:
            AT_ERROR("slow_conv_transpose3d_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_transpose3d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(out, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
#endif
}

// aten::slow_conv_transpose3d(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, int[3] padding=0, int[3] output_padding=0, int[3] dilation=1) -> Tensor
static inline Tensor slow_conv_transpose3d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_transpose3d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
            break;
        default:
            AT_ERROR("slow_conv_transpose3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_transpose3d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
#endif
}

// aten::slow_conv_transpose3d_backward.grad_output(Tensor grad_output, Tensor self, Tensor weight, int[3] kernel_size, int[3] stride, int[3] padding, int[3] output_padding, int[3] dilation, Tensor finput, Tensor fgrad_input, *, Tensor(a!)? grad_input, Tensor(b!)? grad_weight, Tensor(c!)? grad_bias) -> (Tensor(a!), Tensor(b!), Tensor(c!))
static inline std::tuple<Tensor &,Tensor &,Tensor &> slow_conv_transpose3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & finput, const Tensor & fgrad_input) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_weight, grad_bias, grad_output, self, weight, finput, fgrad_input);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_transpose3d_backward_out_grad_output(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, finput, fgrad_input);
            break;
        default:
            AT_ERROR("slow_conv_transpose3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_transpose3d_backward", "grad_output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &,Tensor &>, Tensor &, Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &>(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, finput, fgrad_input);
#endif
}

// aten::slow_conv_transpose3d_backward.output_mask(Tensor grad_output, Tensor self, Tensor weight, int[3] kernel_size, int[3] stride, int[3] padding, int[3] output_padding, int[3] dilation, Tensor finput, Tensor fgrad_input, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias)
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv_transpose3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, weight, finput, fgrad_input);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_transpose3d_backward_output_mask(grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, finput, fgrad_input, output_mask);
            break;
        default:
            AT_ERROR("slow_conv_transpose3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_transpose3d_backward", "output_mask");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &, std::array<bool,3>>(grad_output, self, weight, kernel_size, stride, padding, output_padding, dilation, finput, fgrad_input, output_mask);
#endif
}

// aten::thnn_conv2d.out(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & thnn_conv2d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::thnn_conv2d_out_out(out, self, weight, kernel_size, bias, stride, padding);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef>(out, self, weight, kernel_size, bias, stride, padding);
#endif
}

// aten::thnn_conv2d(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0) -> Tensor
static inline Tensor thnn_conv2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::thnn_conv2d(self, weight, kernel_size, bias, stride, padding);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv2d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding);
#endif
}

// aten::thnn_conv2d_forward.output(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias, int[2] stride, int[2] padding, *, Tensor(a!) output, Tensor(b!) finput, Tensor(c!) fgrad_input) -> (Tensor(a!), Tensor(b!), Tensor(c!))
static inline std::tuple<Tensor &,Tensor &,Tensor &> thnn_conv2d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(output, finput, fgrad_input, self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::thnn_conv2d_forward_out_output(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
            break;
        default:
            AT_ERROR("thnn_conv2d_forward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv2d_forward", "output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &,Tensor &>, Tensor &, Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef>(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
#endif
}

// aten::thnn_conv2d_forward(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias, int[2] stride, int[2] padding) -> (Tensor output, Tensor finput, Tensor fgrad_input)
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_forward(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::thnn_conv2d_forward(self, weight, kernel_size, bias, stride, padding);
            break;
        default:
            AT_ERROR("thnn_conv2d_forward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv2d_forward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding);
#endif
}

// aten::thnn_conv2d_backward.grad_input(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, Tensor finput, Tensor fgrad_input, *, Tensor(a!)? grad_input, Tensor(b!)? grad_weight, Tensor(c!)? grad_bias) -> (Tensor(a!), Tensor(b!), Tensor(c!))
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, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_weight, grad_bias, grad_output, self, weight, finput, fgrad_input);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::thnn_conv2d_backward_out_grad_input(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input);
            break;
        default:
            AT_ERROR("thnn_conv2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv2d_backward", "grad_input");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &,Tensor &>, Tensor &, Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &>(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input);
#endif
}

// aten::thnn_conv2d_backward.output_mask(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, Tensor finput, Tensor fgrad_input, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias)
static inline std::tuple<Tensor,Tensor,Tensor> thnn_conv2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, weight, finput, fgrad_input);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::thnn_conv2d_backward_output_mask(grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input, output_mask);
            break;
        default:
            AT_ERROR("thnn_conv2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv2d_backward", "output_mask");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &, std::array<bool,3>>(grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input, output_mask);
#endif
}

// aten::thnn_conv_depthwise2d.out(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & thnn_conv_depthwise2d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::thnn_conv_depthwise2d_out_out(out, self, weight, kernel_size, bias, stride, padding, dilation);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv_depthwise2d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(out, self, weight, kernel_size, bias, stride, padding, dilation);
#endif
}

// aten::thnn_conv_depthwise2d(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] dilation=1) -> Tensor
static inline Tensor thnn_conv_depthwise2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::thnn_conv_depthwise2d(self, weight, kernel_size, bias, stride, padding, dilation);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv_depthwise2d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding, dilation);
#endif
}

// aten::thnn_conv_depthwise2d_forward.out(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias, int[2] stride, int[2] padding, int[2] dilation, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & thnn_conv_depthwise2d_forward_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("thnn_conv_depthwise2d_forward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv_depthwise2d_forward", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(out, self, weight, kernel_size, bias, stride, padding, dilation);
#endif
}

// aten::thnn_conv_depthwise2d_forward(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias, int[2] stride, int[2] padding, int[2] dilation) -> Tensor
static inline Tensor thnn_conv_depthwise2d_forward(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("thnn_conv_depthwise2d_forward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv_depthwise2d_forward", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding, dilation);
#endif
}

// aten::thnn_conv_depthwise2d_backward.grad_input(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, int[2] dilation, *, Tensor(a!)? grad_input, Tensor(b!)? grad_weight) -> (Tensor(a!), Tensor(b!))
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, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_weight, grad_output, self, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("thnn_conv_depthwise2d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv_depthwise2d_backward", "grad_input");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &>, Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(grad_input, grad_weight, grad_output, self, weight, kernel_size, stride, padding, dilation);
#endif
}

// aten::thnn_conv_depthwise2d_backward.output_mask(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, int[2] dilation, bool[2] output_mask) -> (Tensor grad_input, Tensor grad_weight)
static inline std::tuple<Tensor,Tensor> thnn_conv_depthwise2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, std::array<bool,2> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
    
        default:
            AT_ERROR("thnn_conv_depthwise2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::thnn_conv_depthwise2d_backward", "output_mask");
    return op.callUnboxed<std::tuple<Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, std::array<bool,2>>(grad_output, self, weight, kernel_size, stride, padding, dilation, output_mask);
#endif
}

// aten::slow_conv3d.out(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, int[3] padding=0, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & slow_conv3d_out(Tensor & out, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::slow_conv3d_out_out(out, self, weight, kernel_size, bias, stride, padding);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv3d", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef>(out, self, weight, kernel_size, bias, stride, padding);
#endif
}

// aten::slow_conv3d(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, int[3] padding=0) -> Tensor
static inline Tensor slow_conv3d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::slow_conv3d(self, weight, kernel_size, bias, stride, padding);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv3d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding);
#endif
}

// aten::slow_conv3d_forward.output(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias, int[3] stride, int[3] padding, *, Tensor(a!) output, Tensor(b!) finput, Tensor(c!) fgrad_input) -> (Tensor(a!), Tensor(b!), Tensor(c!))
static inline std::tuple<Tensor &,Tensor &,Tensor &> slow_conv3d_forward_out(Tensor & output, Tensor & finput, Tensor & fgrad_input, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(output, finput, fgrad_input, self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv3d_forward_out_output(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
            break;
        default:
            AT_ERROR("slow_conv3d_forward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv3d_forward", "output");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &,Tensor &>, Tensor &, Tensor &, Tensor &, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef>(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
#endif
}

// aten::slow_conv3d_forward(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias, int[3] stride, int[3] padding) -> (Tensor output, Tensor finput, Tensor fgrad_input)
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv3d_forward(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv3d_forward(self, weight, kernel_size, bias, stride, padding);
            break;
        default:
            AT_ERROR("slow_conv3d_forward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv3d_forward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding);
#endif
}

// aten::slow_conv3d_backward.grad_input(Tensor grad_output, Tensor self, Tensor weight, int[3] kernel_size, int[3] stride, int[3] padding, Tensor finput, Tensor fgrad_input, *, Tensor(a!)? grad_input, Tensor(b!)? grad_weight, Tensor(c!)? grad_bias) -> (Tensor(a!), Tensor(b!), Tensor(c!))
static inline std::tuple<Tensor &,Tensor &,Tensor &> slow_conv3d_backward_out(Tensor & grad_input, Tensor & grad_weight, Tensor & grad_bias, const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_weight, grad_bias, grad_output, self, weight, finput, fgrad_input);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv3d_backward_out_grad_input(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input);
            break;
        default:
            AT_ERROR("slow_conv3d_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv3d_backward", "grad_input");
    return op.callUnboxed<std::tuple<Tensor &,Tensor &,Tensor &>, Tensor &, Tensor &, Tensor &, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &>(grad_input, grad_weight, grad_bias, grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input);
#endif
}

// aten::slow_conv3d_backward.output_mask(Tensor grad_output, Tensor self, Tensor weight, int[3] kernel_size, int[3] stride, int[3] padding, Tensor finput, Tensor fgrad_input, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias)
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, const Tensor & finput, const Tensor & fgrad_input, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, weight, finput, fgrad_input);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv3d_backward_output_mask(grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input, output_mask);
            break;
        default:
            AT_ERROR("slow_conv3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv3d_backward", "output_mask");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, const Tensor &, const Tensor &, std::array<bool,3>>(grad_output, self, weight, kernel_size, stride, padding, finput, fgrad_input, output_mask);
#endif
}

// aten::slow_conv_dilated2d(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0, int[2] dilation=1) -> Tensor
static inline Tensor slow_conv_dilated2d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_dilated2d(self, weight, kernel_size, bias, stride, padding, dilation);
            break;
        default:
            AT_ERROR("slow_conv_dilated2d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_dilated2d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding, dilation);
#endif
}

// aten::slow_conv_dilated2d_backward(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, int[2] dilation, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias)
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv_dilated2d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_dilated2d_backward(grad_output, self, weight, kernel_size, stride, padding, dilation, output_mask);
            break;
        default:
            AT_ERROR("slow_conv_dilated2d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_dilated2d_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, std::array<bool,3>>(grad_output, self, weight, kernel_size, stride, padding, dilation, output_mask);
#endif
}

// aten::slow_conv_dilated3d(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, int[3] padding=0, int[3] dilation=1) -> Tensor
static inline Tensor slow_conv_dilated3d(const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, const Tensor & bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self, weight, bias);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_dilated3d(self, weight, kernel_size, bias, stride, padding, dilation);
            break;
        default:
            AT_ERROR("slow_conv_dilated3d not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_dilated3d", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, IntArrayRef, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef>(self, weight, kernel_size, bias, stride, padding, dilation);
#endif
}

// aten::slow_conv_dilated3d_backward(Tensor grad_output, Tensor self, Tensor weight, int[3] kernel_size, int[3] stride, int[3] padding, int[3] dilation, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias)
static inline std::tuple<Tensor,Tensor,Tensor> slow_conv_dilated3d_backward(const Tensor & grad_output, const Tensor & self, const Tensor & weight, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, std::array<bool,3> output_mask) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output, self, weight);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::slow_conv_dilated3d_backward(grad_output, self, weight, kernel_size, stride, padding, dilation, output_mask);
            break;
        default:
            AT_ERROR("slow_conv_dilated3d_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::slow_conv_dilated3d_backward", "");
    return op.callUnboxed<std::tuple<Tensor,Tensor,Tensor>, const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, std::array<bool,3>>(grad_output, self, weight, kernel_size, stride, padding, dilation, output_mask);
#endif
}

// aten::col2im.out(Tensor self, int[2] output_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & col2im_out(Tensor & out, const Tensor & self, IntArrayRef output_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::col2im_out_out(out, self, output_size, kernel_size, dilation, padding, stride);
            break;
        default:
            AT_ERROR("col2im_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::col2im", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(out, self, output_size, kernel_size, dilation, padding, stride);
#endif
}

// aten::col2im(Tensor self, int[2] output_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride) -> Tensor
static inline Tensor col2im(const Tensor & self, IntArrayRef output_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::col2im(self, output_size, kernel_size, dilation, padding, stride);
            break;
        default:
            AT_ERROR("col2im not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::col2im", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(self, output_size, kernel_size, dilation, padding, stride);
#endif
}

// aten::col2im_backward.grad_input(Tensor grad_output, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & col2im_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::col2im_backward_out_grad_input(grad_input, grad_output, kernel_size, dilation, padding, stride);
            break;
        default:
            AT_ERROR("col2im_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::col2im_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(grad_input, grad_output, kernel_size, dilation, padding, stride);
#endif
}

// aten::col2im_backward(Tensor grad_output, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride) -> Tensor
static inline Tensor col2im_backward(const Tensor & grad_output, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::col2im_backward(grad_output, kernel_size, dilation, padding, stride);
            break;
        default:
            AT_ERROR("col2im_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::col2im_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(grad_output, kernel_size, dilation, padding, stride);
#endif
}

// aten::im2col.out(Tensor self, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride, *, Tensor(a!) out) -> Tensor(a!)
static inline Tensor & im2col_out(Tensor & out, const Tensor & self, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(out, self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::im2col_out_out(out, self, kernel_size, dilation, padding, stride);
            break;
        default:
            AT_ERROR("im2col_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::im2col", "out");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(out, self, kernel_size, dilation, padding, stride);
#endif
}

// aten::im2col(Tensor self, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride) -> Tensor
static inline Tensor im2col(const Tensor & self, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(self);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::im2col(self, kernel_size, dilation, padding, stride);
            break;
        default:
            AT_ERROR("im2col not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::im2col", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(self, kernel_size, dilation, padding, stride);
#endif
}

// aten::im2col_backward.grad_input(Tensor grad_output, int[2] input_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride, *, Tensor(a!) grad_input) -> Tensor(a!)
static inline Tensor & im2col_backward_out(Tensor & grad_input, const Tensor & grad_output, IntArrayRef input_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_input, grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::im2col_backward_out_grad_input(grad_input, grad_output, input_size, kernel_size, dilation, padding, stride);
            break;
        default:
            AT_ERROR("im2col_backward_out not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::im2col_backward", "grad_input");
    return op.callUnboxed<Tensor &, Tensor &, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(grad_input, grad_output, input_size, kernel_size, dilation, padding, stride);
#endif
}

// aten::im2col_backward(Tensor grad_output, int[2] input_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride) -> Tensor
static inline Tensor im2col_backward(const Tensor & grad_output, IntArrayRef input_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    DispatchKeySet _dk_set = c10::detail::multi_dispatch_key_set(grad_output);
    DispatchKeySet _dk_mask = c10::DispatchKeySet(DispatchKeySet::FULL_AFTER, DispatchKey::BackendSelect);
    DispatchKey _dk = c10::impl::dispatchTypeId(_dk_set, _dk_mask);
    switch (dispatchKeyToBackend(_dk)) {
        case Backend::CPU:
            return CPUType::im2col_backward(grad_output, input_size, kernel_size, dilation, padding, stride);
            break;
        default:
            AT_ERROR("im2col_backward not implemented for ", at::toString(_dk));
    }
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::im2col_backward", "");
    return op.callUnboxed<Tensor, const Tensor &, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef, IntArrayRef>(grad_output, input_size, kernel_size, dilation, padding, stride);
#endif
}

// aten::isfinite(Tensor self) -> Tensor
static inline Tensor isfinite(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::isfinite(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::isfinite", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::isinf(Tensor self) -> Tensor
static inline Tensor isinf(const Tensor & self) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::isinf(self);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::isinf", "");
    return op.callUnboxed<Tensor, const Tensor &>(self);
#endif
}

// aten::_test_serialization_subcmul(Tensor self, Tensor other, Scalar alpha=1) -> Tensor
static inline Tensor _test_serialization_subcmul(const Tensor & self, const Tensor & other, Scalar alpha) {
#ifdef USE_STATIC_DISPATCH
    at::AutoNonVariableTypeMode _var_guard(true);
    return TypeDefault::_test_serialization_subcmul(self, other, alpha);
#else
    static c10::OperatorHandle op = c10::Dispatcher::singleton()
        .findSchemaOrThrow("aten::_test_serialization_subcmul", "");
    return op.callUnboxed<Tensor, const Tensor &, const Tensor &, Scalar>(self, other, alpha);
#endif
}

}
